@flink-app/flink 0.4.7 → 0.5.0

package/dist/src/FlinkApp.d.ts

@@ -112,6 +112,21 @@ export interface FlinkOptions {
      * Only useful when starting a Flink app for testing purposes.
      */
     disableHttpServer?: boolean;
+    /**
+     * Configuration for access logs.
+     */
+    accessLog?: {
+        /**
+         * Enables access logs for all requests.
+         * Defaults to true.
+         */
+        enabled?: boolean;
+        /**
+         * Optional custom format.
+         * Uses `morgan` format and defaults to `dev`.
+         */
+        format?: string;
+    };
 }
 export interface HandlerConfig {
     schema?: {
@@ -157,6 +172,7 @@ export declare class FlinkApp<C extends FlinkContext> {
      */
     private handlerRouteCache;
     scheduler?: ToadScheduler;
+    private accessLog;
     constructor(opts: FlinkOptions);
     get ctx(): C;
     start(): Promise<this>;

package/dist/src/FlinkApp.js

@@ -57,6 +57,7 @@ var body_parser_1 = __importDefault(require("body-parser"));
 var cors_1 = __importDefault(require("cors"));
 var express_1 = __importDefault(require("express"));
 var mongodb_1 = __importDefault(require("mongodb"));
+var morgan_1 = __importDefault(require("morgan"));
 var ms_1 = __importDefault(require("ms"));
 var toad_scheduler_1 = require("toad-scheduler");
 var uuid_1 = require("uuid");
@@ -110,6 +111,7 @@ var FlinkApp = /** @class */ (function () {
         this.jsonOptions = opts.jsonOptions || { limit: "1mb" };
         this.schedulingOptions = opts.scheduling;
         this.disableHttpServer = !!opts.disableHttpServer;
+        this.accessLog = __assign({ enabled: true, format: "dev" }, opts.accessLog);
     }
     Object.defineProperty(FlinkApp.prototype, "ctx", {
         get: function () {
@@ -155,6 +157,9 @@ var FlinkApp = /** @class */ (function () {
                             this.expressApp = express_1.default();
                             this.expressApp.use(cors_1.default(this.corsOpts));
                             this.expressApp.use(body_parser_1.default.json(this.jsonOptions));
+                            if (this.accessLog.enabled) {
+                                this.expressApp.use(morgan_1.default(this.accessLog.format));
+                            }
                             this.expressApp.use(function (req, res, next) {
                                 req.reqId = uuid_1.v4();
                                 next();
@@ -281,8 +286,16 @@ var FlinkApp = /** @class */ (function () {
             if (this.disableHttpServer) {
                 return;
             }
+            var validateReq_1;
+            var validateRes_1;
+            if (schema.reqSchema) {
+                validateReq_1 = ajv.compile(schema.reqSchema);
+            }
+            if (schema.resSchema) {
+                validateRes_1 = ajv.compile(schema.resSchema);
+            }
             this.expressApp[method](routeProps.path, function (req, res) { return __awaiter(_this, void 0, void 0, function () {
-                var validate, valid, data, handlerRes, err_1, validate, valid;
+                var valid, data, handlerRes, err_1, valid;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
@@ -294,18 +307,17 @@ var FlinkApp = /** @class */ (function () {
                             }
                             _a.label = 2;
                         case 2:
-                            if (schema.reqSchema) {
-                                validate = ajv.compile(schema.reqSchema);
-                                valid = validate(req.body);
+                            if (validateReq_1) {
+                                valid = validateReq_1(req.body);
                                 if (!valid) {
-                                    FlinkLog_1.log.warn(methodAndRoute_1 + ": Bad request " + JSON.stringify(validate.errors, null, 2));
+                                    FlinkLog_1.log.warn(methodAndRoute_1 + ": Bad request " + JSON.stringify(validateReq_1.errors, null, 2));
                                     FlinkLog_1.log.debug("Invalid json: " + JSON.stringify(req.body));
                                     return [2 /*return*/, res.status(400).json({
                                             status: 400,
                                             error: {
                                                 id: uuid_1.v4(),
                                                 title: "Bad request",
-                                                detail: "Schema did not validate " + JSON.stringify(validate.errors),
+                                                detail: "Schema did not validate " + JSON.stringify(validateReq_1.errors),
                                             },
                                         })];
                                 }
@@ -337,11 +349,10 @@ var FlinkApp = /** @class */ (function () {
                             console.error(err_1);
                             return [2 /*return*/, res.status(500).json(FlinkErrors_1.internalServerError(err_1))];
                         case 6:
-                            if (schema.resSchema && !utils_1.isError(handlerRes)) {
-                                validate = ajv.compile(schema.resSchema);
-                                valid = validate(JSON.parse(JSON.stringify(handlerRes.data)));
+                            if (validateRes_1 && !utils_1.isError(handlerRes)) {
+                                valid = validateRes_1(JSON.parse(JSON.stringify(handlerRes.data)));
                                 if (!valid) {
-                                    FlinkLog_1.log.warn("[" + req.reqId + "] " + methodAndRoute_1 + ": Bad response " + JSON.stringify(validate.errors, null, 2));
+                                    FlinkLog_1.log.warn("[" + req.reqId + "] " + methodAndRoute_1 + ": Bad response " + JSON.stringify(validateRes_1.errors, null, 2));
                                     FlinkLog_1.log.debug("Invalid json: " + JSON.stringify(handlerRes.data));
                                     // log.debug(JSON.stringify(schema, null, 2));
                                     return [2 /*return*/, res.status(500).json({
@@ -349,7 +360,7 @@ var FlinkApp = /** @class */ (function () {
                                             error: {
                                                 id: uuid_1.v4(),
                                                 title: "Bad response",
-                                                detail: "Schema did not validate " + JSON.stringify(validate.errors),
+                                                detail: "Schema did not validate " + JSON.stringify(validateRes_1.errors),
                                             },
                                         })];
                                 }
@@ -377,12 +388,12 @@ var FlinkApp = /** @class */ (function () {
      * Will not register any handlers added programmatically.
      */
     FlinkApp.prototype.registerAutoRegisterableHandlers = function () {
-        var _a, _b;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function () {
-            var _i, autoRegisteredHandlers_1, _c, handler, assumedHttpMethod;
-            return __generator(this, function (_d) {
+            var _i, autoRegisteredHandlers_1, _d, handler, assumedHttpMethod, pathParams, _e, _f, param;
+            return __generator(this, function (_g) {
                 for (_i = 0, autoRegisteredHandlers_1 = exports.autoRegisteredHandlers; _i < autoRegisteredHandlers_1.length; _i++) {
-                    _c = autoRegisteredHandlers_1[_i], handler = _c.handler, assumedHttpMethod = _c.assumedHttpMethod;
+                    _d = autoRegisteredHandlers_1[_i], handler = _d.handler, assumedHttpMethod = _d.assumedHttpMethod;
                     if (!handler.Route) {
                         FlinkLog_1.log.error("Missing Props in handler " + handler.__file);
                         continue;
@@ -391,11 +402,24 @@ var FlinkApp = /** @class */ (function () {
                         FlinkLog_1.log.error("Missing exported handler function in handler " + handler.__file);
                         continue;
                     }
+                    if (!!((_a = handler.__params) === null || _a === void 0 ? void 0 : _a.length)) {
+                        pathParams = utils_1.getPathParams(handler.Route.path);
+                        for (_e = 0, _f = handler.__params; _e < _f.length; _e++) {
+                            param = _f[_e];
+                            if (!pathParams.includes(param.name)) {
+                                FlinkLog_1.log.error("Handler " + handler.__file + " has param " + param.name + " but it is not present in the path '" + handler.Route.path + "'");
+                                throw new Error("Invalid/missing handler path param");
+                            }
+                        }
+                        if (pathParams.length !== handler.__params.length) {
+                            FlinkLog_1.log.warn("Handler " + handler.__file + " has " + handler.__params.length + " typed params but the path '" + handler.Route.path + "' has " + pathParams.length + " params");
+                        }
+                    }
                     this.registerHandler({
                         routeProps: __assign(__assign({}, handler.Route), { method: handler.Route.method || assumedHttpMethod, origin: this.name }),
                         schema: {
-                            reqSchema: (_a = handler.__schemas) === null || _a === void 0 ? void 0 : _a.reqSchema,
-                            resSchema: (_b = handler.__schemas) === null || _b === void 0 ? void 0 : _b.resSchema,
+                            reqSchema: (_b = handler.__schemas) === null || _b === void 0 ? void 0 : _b.reqSchema,
+                            resSchema: (_c = handler.__schemas) === null || _c === void 0 ? void 0 : _c.resSchema,
                         },
                         queryMetadata: handler.__query || [],
                         paramsMetadata: handler.__params || [],

package/dist/src/utils.d.ts

@@ -18,3 +18,10 @@ export declare function getRepoInstanceName(fn: string): string;
  */
 export declare function getHttpMethodFromHandlerName(handlerFilename: string): HttpMethod | undefined;
 export declare function getJsDocComment(comment: string): string;
+/**
+ * Returns array of path params from path string.
+ * For example `/user/:id` will return `["id"]`
+ * @param path
+ * @returns
+ */
+export declare function getPathParams(path: string): string[];

package/dist/src/utils.js

@@ -39,7 +39,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getJsDocComment = exports.getHttpMethodFromHandlerName = exports.getRepoInstanceName = exports.getCollectionNameForRepo = exports.getSchemaFiles = exports.getHandlerFiles = exports.isError = exports.isRouteMatch = exports.schemasPath = exports.handlersPath = void 0;
+exports.getPathParams = exports.getJsDocComment = exports.getHttpMethodFromHandlerName = exports.getRepoInstanceName = exports.getCollectionNameForRepo = exports.getSchemaFiles = exports.getHandlerFiles = exports.isError = exports.isRouteMatch = exports.schemasPath = exports.handlersPath = void 0;
 var path_1 = require("path");
 var tiny_glob_1 = __importDefault(require("tiny-glob"));
 var FlinkHttpHandler_1 = require("./FlinkHttpHandler");
@@ -149,3 +149,15 @@ function getJsDocComment(comment) {
     return rows.join("\n").trim();
 }
 exports.getJsDocComment = getJsDocComment;
+var pathParamsRegex = /:([a-zA-Z0-9]+)/g;
+/**
+ * Returns array of path params from path string.
+ * For example `/user/:id` will return `["id"]`
+ * @param path
+ * @returns
+ */
+function getPathParams(path) {
+    var _a;
+    return ((_a = path.match(pathParamsRegex)) === null || _a === void 0 ? void 0 : _a.map(function (match) { return match.slice(1); })) || [];
+}
+exports.getPathParams = getPathParams;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@flink-app/flink",
-    "version": "0.4.7",
+    "version": "0.5.0",
     "description": "Typescript only framework for creating REST-like APIs on top of Express and mongodb",
     "types": "dist/src/index.d.ts",
     "main": "dist/src/index.js",
@@ -40,6 +40,7 @@
         "mkdirp": "^1.0.4",
         "mock-json-schema": "^1.0.8",
         "mongodb": "^3.6.6",
+        "morgan": "^1.10.0",
         "ms": "^2.0.0",
         "node-color-log": "^10.0.2",
         "passport": "^0.4.1",
@@ -57,6 +58,7 @@
         "@types/jasmine": "^3.7.1",
         "@types/json-schema": "^7.0.7",
         "@types/mkdirp": "^1.0.1",
+        "@types/morgan": "^1.9.4",
         "@types/node": "^15.0.1",
         "jasmine": "^3.7.0",
         "jasmine-spec-reporter": "^7.0.0",
@@ -65,5 +67,5 @@
         "rimraf": "^3.0.2",
         "ts-node": "^9.1.1"
     },
-    "gitHead": "b565d5987e08ba3aba3653325e935e6c56cab24c"
+    "gitHead": "3c877c210da19119c074c7482e97a485d2334e80"
 }

package/src/FlinkApp.ts

@@ -1,10 +1,11 @@
-import Ajv from "ajv";
+import Ajv, { ValidateFunction } from "ajv";
 import addFormats from "ajv-formats";
 import bodyParser, { OptionsJson } from "body-parser";
 import cors from "cors";
 import express, { Express, Request } from "express";
 import { JSONSchema7 } from "json-schema";
 import mongodb, { Db } from "mongodb";
+import morgan from "morgan";
 import ms from "ms";
 import { AsyncTask, CronJob, SimpleIntervalJob, ToadScheduler } from "toad-scheduler";
 import { v4 } from "uuid";
@@ -18,7 +19,7 @@ import { FlinkPlugin } from "./FlinkPlugin";
 import { FlinkRepo } from "./FlinkRepo";
 import { FlinkResponse } from "./FlinkResponse";
 import generateMockData from "./mock-data-generator";
-import { isError } from "./utils";
+import { getPathParams, isError } from "./utils";
 
 const ajv = new Ajv();
 addFormats(ajv);
@@ -168,6 +169,23 @@ export interface FlinkOptions {
      * Only useful when starting a Flink app for testing purposes.
      */
     disableHttpServer?: boolean;
+
+    /**
+     * Configuration for access logs.
+     */
+    accessLog?: {
+        /**
+         * Enables access logs for all requests.
+         * Defaults to true.
+         */
+        enabled?: boolean;
+
+        /**
+         * Optional custom format.
+         * Uses `morgan` format and defaults to `dev`.
+         */
+        format?: string;
+    };
 }
 
 export interface HandlerConfig {
@@ -220,6 +238,8 @@ export class FlinkApp<C extends FlinkContext> {
 
     public scheduler?: ToadScheduler;
 
+    private accessLog: { enabled: boolean; format: string };
+
     constructor(opts: FlinkOptions) {
         this.name = opts.name;
         this.port = opts.port || 3333;
@@ -232,6 +252,7 @@ export class FlinkApp<C extends FlinkContext> {
         this.jsonOptions = opts.jsonOptions || { limit: "1mb" };
         this.schedulingOptions = opts.scheduling;
         this.disableHttpServer = !!opts.disableHttpServer;
+        this.accessLog = { enabled: true, format: "dev", ...opts.accessLog };
     }
 
     get ctx() {
@@ -267,11 +288,13 @@ export class FlinkApp<C extends FlinkContext> {
 
         if (!this.disableHttpServer) {
             this.expressApp = express();
-
             this.expressApp.use(cors(this.corsOpts));
-
             this.expressApp.use(bodyParser.json(this.jsonOptions));
 
+            if (this.accessLog.enabled) {
+                this.expressApp.use(morgan(this.accessLog.format));
+            }
+
             this.expressApp.use((req, res, next) => {
                 req.reqId = v4();
                 next();
@@ -411,6 +434,17 @@ export class FlinkApp<C extends FlinkContext> {
                 return;
             }
 
+            let validateReq: ValidateFunction<any> | undefined;
+            let validateRes: ValidateFunction<any> | undefined;
+
+            if (schema.reqSchema) {
+                validateReq = ajv.compile(schema.reqSchema);
+            }
+
+            if (schema.resSchema) {
+                validateRes = ajv.compile(schema.resSchema);
+            }
+
             this.expressApp![method](routeProps.path, async (req, res) => {
                 if (routeProps.permissions) {
                     if (!(await this.authenticate(req, routeProps.permissions))) {
@@ -418,12 +452,11 @@ export class FlinkApp<C extends FlinkContext> {
                     }
                 }
 
-                if (schema.reqSchema) {
-                    const validate = ajv.compile(schema.reqSchema);
-                    const valid = validate(req.body);
+                if (validateReq) {
+                    const valid = validateReq(req.body);
 
                     if (!valid) {
-                        log.warn(`${methodAndRoute}: Bad request ${JSON.stringify(validate.errors, null, 2)}`);
+                        log.warn(`${methodAndRoute}: Bad request ${JSON.stringify(validateReq.errors, null, 2)}`);
 
                         log.debug(`Invalid json: ${JSON.stringify(req.body)}`);
 
@@ -432,7 +465,7 @@ export class FlinkApp<C extends FlinkContext> {
                             error: {
                                 id: v4(),
                                 title: "Bad request",
-                                detail: `Schema did not validate ${JSON.stringify(validate.errors)}`,
+                                detail: `Schema did not validate ${JSON.stringify(validateReq.errors)}`,
                             },
                         });
                     }
@@ -465,12 +498,11 @@ export class FlinkApp<C extends FlinkContext> {
                     return res.status(500).json(internalServerError(err as any));
                 }
 
-                if (schema.resSchema && !isError(handlerRes)) {
-                    const validate = ajv.compile(schema.resSchema);
-                    const valid = validate(JSON.parse(JSON.stringify(handlerRes.data)));
+                if (validateRes && !isError(handlerRes)) {
+                    const valid = validateRes(JSON.parse(JSON.stringify(handlerRes.data)));
 
                     if (!valid) {
-                        log.warn(`[${req.reqId}] ${methodAndRoute}: Bad response ${JSON.stringify(validate.errors, null, 2)}`);
+                        log.warn(`[${req.reqId}] ${methodAndRoute}: Bad response ${JSON.stringify(validateRes.errors, null, 2)}`);
                         log.debug(`Invalid json: ${JSON.stringify(handlerRes.data)}`);
                         // log.debug(JSON.stringify(schema, null, 2));
 
@@ -479,7 +511,7 @@ export class FlinkApp<C extends FlinkContext> {
                             error: {
                                 id: v4(),
                                 title: "Bad response",
-                                detail: `Schema did not validate ${JSON.stringify(validate.errors)}`,
+                                detail: `Schema did not validate ${JSON.stringify(validateRes.errors)}`,
                             },
                         });
                     }
@@ -518,6 +550,23 @@ export class FlinkApp<C extends FlinkContext> {
                 continue;
             }
 
+            if (!!handler.__params?.length) {
+                const pathParams = getPathParams(handler.Route.path);
+
+                for (const param of handler.__params) {
+                    if (!pathParams.includes(param.name)) {
+                        log.error(`Handler ${handler.__file} has param ${param.name} but it is not present in the path '${handler.Route.path}'`);
+                        throw new Error("Invalid/missing handler path param");
+                    }
+                }
+
+                if (pathParams.length !== handler.__params.length) {
+                    log.warn(
+                        `Handler ${handler.__file} has ${handler.__params.length} typed params but the path '${handler.Route.path}' has ${pathParams.length} params`
+                    );
+                }
+            }
+
             this.registerHandler(
                 {
                     routeProps: {

package/src/utils.ts

@@ -88,3 +88,15 @@ export function getJsDocComment(comment: string) {
 
     return rows.join("\n").trim();
 }
+
+const pathParamsRegex = /:([a-zA-Z0-9]+)/g;
+
+/**
+ * Returns array of path params from path string.
+ * For example `/user/:id` will return `["id"]`
+ * @param path
+ * @returns
+ */
+export function getPathParams(path: string) {
+    return path.match(pathParamsRegex)?.map((match) => match.slice(1)) || [];
+}