@flink-app/flink 0.13.4 → 0.13.5

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @flink-app/flink
 
+## 0.13.5
+
+### Patch Changes
+
+-   Schema error DX improvement - i.e. better logs
+
 ## 0.13.4
 
 ### Patch Changes

package/dist/src/FlinkApp.js

@@ -341,7 +341,7 @@ var FlinkApp = /** @class */ (function () {
                 validateRes_1 = ajv.compile(schema.resSchema);
             }
             this.expressApp[method](routeProps.path, function (req, res) { return __awaiter(_this, void 0, void 0, function () {
-                var valid, data, handlerRes, err_1, valid;
+                var valid, formattedErrors, data, handlerRes, err_1, valid, formattedErrors;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
@@ -356,8 +356,8 @@ var FlinkApp = /** @class */ (function () {
                             if (validateReq_1) {
                                 valid = validateReq_1(req.body);
                                 if (!valid) {
-                                    FlinkLog_1.log.warn("".concat(methodAndRoute_1, ": Bad request ").concat(JSON.stringify(validateReq_1.errors, null, 2)));
-                                    FlinkLog_1.log.debug("Invalid json: ".concat(JSON.stringify(req.body)));
+                                    formattedErrors = (0, utils_1.formatValidationErrors)(validateReq_1.errors, req.body);
+                                    FlinkLog_1.log.warn("[".concat(req.reqId, "] ").concat(methodAndRoute_1, ": Bad request\n").concat(formattedErrors));
                                     return [2 /*return*/, res.status(400).json({
                                             status: 400,
                                             error: {
@@ -410,9 +410,8 @@ var FlinkApp = /** @class */ (function () {
                             if (validateRes_1 && !(0, utils_1.isError)(handlerRes)) {
                                 valid = validateRes_1(JSON.parse(JSON.stringify(handlerRes.data)));
                                 if (!valid) {
-                                    FlinkLog_1.log.warn("[".concat(req.reqId, "] ").concat(methodAndRoute_1, ": Bad response ").concat(JSON.stringify(validateRes_1.errors, null, 2)));
-                                    FlinkLog_1.log.debug("Invalid json: ".concat(JSON.stringify(handlerRes.data)));
-                                    // log.debug(JSON.stringify(schema, null, 2));
+                                    formattedErrors = (0, utils_1.formatValidationErrors)(validateRes_1.errors, handlerRes.data);
+                                    FlinkLog_1.log.warn("[".concat(req.reqId, "] ").concat(methodAndRoute_1, ": Bad response\n").concat(formattedErrors));
                                     return [2 /*return*/, res.status(500).json({
                                             status: 500,
                                             error: {

package/dist/src/utils.d.ts

@@ -25,3 +25,15 @@ export declare function getJsDocComment(comment: string): string;
  * @returns
  */
 export declare function getPathParams(path: string): string[];
+/**
+ * Extracts data at a given JSON path (e.g., "/jobs/5/result")
+ * Returns the value at that path, or undefined if not found
+ */
+export declare function getDataAtPath(data: any, instancePath: string): any;
+/**
+ * Formats validation errors with context about the problematic data
+ * @param errors AJV validation errors
+ * @param data The full data object that failed validation
+ * @param maxDataLength Maximum length of data to show (default 500)
+ */
+export declare function formatValidationErrors(errors: any[] | null | undefined, data: any, maxDataLength?: number): string;

package/dist/src/utils.js

@@ -50,6 +50,8 @@ exports.getRepoInstanceName = getRepoInstanceName;
 exports.getHttpMethodFromHandlerName = getHttpMethodFromHandlerName;
 exports.getJsDocComment = getJsDocComment;
 exports.getPathParams = getPathParams;
+exports.getDataAtPath = getDataAtPath;
+exports.formatValidationErrors = formatValidationErrors;
 var path_1 = require("path");
 var tiny_glob_1 = __importDefault(require("tiny-glob"));
 var FlinkHttpHandler_1 = require("./FlinkHttpHandler");
@@ -162,3 +164,72 @@ function getPathParams(path) {
     var _a;
     return ((_a = path.match(pathParamsRegex)) === null || _a === void 0 ? void 0 : _a.map(function (match) { return match.slice(1); })) || [];
 }
+/**
+ * Extracts data at a given JSON path (e.g., "/jobs/5/result")
+ * Returns the value at that path, or undefined if not found
+ */
+function getDataAtPath(data, instancePath) {
+    if (!instancePath || instancePath === "/") {
+        return data;
+    }
+    var parts = instancePath.split("/").filter(function (p) { return p.length > 0; });
+    var current = data;
+    for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+        var part = parts_1[_i];
+        if (current === undefined || current === null) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Formats validation errors with context about the problematic data
+ * @param errors AJV validation errors
+ * @param data The full data object that failed validation
+ * @param maxDataLength Maximum length of data to show (default 500)
+ */
+function formatValidationErrors(errors, data, maxDataLength) {
+    if (maxDataLength === void 0) { maxDataLength = 500; }
+    if (!errors || errors.length === 0) {
+        return "Unknown validation error";
+    }
+    var formatted = [];
+    // Group errors by instance path to avoid repetition
+    var errorsByPath = new Map();
+    for (var _i = 0, errors_1 = errors; _i < errors_1.length; _i++) {
+        var error = errors_1[_i];
+        var path = error.instancePath || "/";
+        if (!errorsByPath.has(path)) {
+            errorsByPath.set(path, []);
+        }
+        errorsByPath.get(path).push(error);
+    }
+    errorsByPath.forEach(function (pathErrors, path) {
+        var dataAtPath = getDataAtPath(data, path);
+        var dataStr = JSON.stringify(dataAtPath);
+        // Truncate if too long
+        if (dataStr.length > maxDataLength) {
+            dataStr = dataStr.substring(0, maxDataLength) + "... (truncated)";
+        }
+        formatted.push("\nPath: ".concat(path));
+        formatted.push("Data: ".concat(dataStr));
+        formatted.push("Errors:");
+        for (var _i = 0, pathErrors_1 = pathErrors; _i < pathErrors_1.length; _i++) {
+            var error = pathErrors_1[_i];
+            if (error.keyword === "required") {
+                formatted.push("  - Missing required property: ".concat(error.params.missingProperty));
+            }
+            else if (error.keyword === "type") {
+                formatted.push("  - Invalid type at ".concat(error.schemaPath, ": expected ").concat(error.params.type, ", got ").concat(typeof dataAtPath));
+            }
+            else if (error.keyword === "anyOf" || error.keyword === "oneOf") {
+                formatted.push("  - ".concat(error.message));
+            }
+            else {
+                formatted.push("  - ".concat(error.message, " (").concat(error.keyword, ")"));
+            }
+        }
+    });
+    return formatted.join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flink-app/flink",
-  "version": "0.13.4",
+  "version": "0.13.5",
   "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",

package/spec/utils.spec.ts

@@ -1,5 +1,5 @@
 import { JSONSchema7 } from "json-schema";
-import { getJsDocComment } from "../src/utils";
+import { formatValidationErrors, getDataAtPath, getJsDocComment } from "../src/utils";
 
 describe("Utils", () => {
     describe("getJsDocComment", () => {
@@ -15,6 +15,140 @@ describe("Utils", () => {
             expect(getJsDocComment(comment)).toBe("Hello world\nThis is another line\nThis line contains a * (asterisk)");
         });
     });
+
+    describe("getDataAtPath", () => {
+        it("should extract data at root path", () => {
+            const data = { foo: "bar" };
+            expect(getDataAtPath(data, "/")).toEqual({ foo: "bar" });
+        });
+
+        it("should extract nested data", () => {
+            const data = { jobs: [{ id: 1 }, { id: 2 }, { id: 3, result: { seed: "123" } }] };
+            expect(getDataAtPath(data, "/jobs/2/result")).toEqual({ seed: "123" });
+        });
+
+        it("should return undefined for non-existent path", () => {
+            const data = { jobs: [{ id: 1 }] };
+            expect(getDataAtPath(data, "/jobs/5/result")).toBeUndefined();
+        });
+    });
+
+    describe("formatValidationErrors", () => {
+        it("should format simple validation errors with data context", () => {
+            const errors = [
+                {
+                    instancePath: "/name",
+                    schemaPath: "#/properties/name/type",
+                    keyword: "type",
+                    params: { type: "string" },
+                    message: "must be string",
+                },
+            ];
+            const data = { name: 123 };
+
+            const formatted = formatValidationErrors(errors, data);
+
+            expect(formatted).toContain('Path: /name');
+            expect(formatted).toContain('Data: 123');
+            expect(formatted).toContain('expected string');
+        });
+
+        it("should format missing required property errors", () => {
+            const errors = [
+                {
+                    instancePath: "/user",
+                    schemaPath: "#/properties/user/required",
+                    keyword: "required",
+                    params: { missingProperty: "email" },
+                    message: "must have required property 'email'",
+                },
+            ];
+            const data = { user: { name: "John" } };
+
+            const formatted = formatValidationErrors(errors, data);
+
+            expect(formatted).toContain('Path: /user');
+            expect(formatted).toContain('Data: {"name":"John"}');
+            expect(formatted).toContain('Missing required property: email');
+        });
+
+        it("should format errors for array items", () => {
+            const errors = [
+                {
+                    instancePath: "/jobs/5/result",
+                    schemaPath: "#/properties/jobs/items/properties/result/anyOf",
+                    keyword: "anyOf",
+                    params: {},
+                    message: "must match a schema in anyOf",
+                },
+            ];
+            const data = {
+                jobs: [
+                    { result: { seed: 1 } },
+                    { result: { seed: 2 } },
+                    { result: { seed: 3 } },
+                    { result: { seed: 4 } },
+                    { result: { seed: 5 } },
+                    { result: { seed: "wrong-type" } }, // This is item 5 (0-indexed)
+                ],
+            };
+
+            const formatted = formatValidationErrors(errors, data);
+
+            expect(formatted).toContain('Path: /jobs/5/result');
+            expect(formatted).toContain('Data: {"seed":"wrong-type"}');
+            expect(formatted).toContain('must match a schema in anyOf');
+        });
+
+        it("should truncate very long data", () => {
+            const errors = [
+                {
+                    instancePath: "/data",
+                    schemaPath: "#/properties/data/type",
+                    keyword: "type",
+                    params: { type: "string" },
+                    message: "must be string",
+                },
+            ];
+            const longString = "x".repeat(1000);
+            const data = { data: longString };
+
+            const formatted = formatValidationErrors(errors, data, 100);
+
+            expect(formatted).toContain('(truncated)');
+            expect(formatted.length).toBeLessThan(500);
+        });
+
+        it("should group multiple errors for the same path", () => {
+            const errors = [
+                {
+                    instancePath: "/user",
+                    schemaPath: "#/properties/user/required",
+                    keyword: "required",
+                    params: { missingProperty: "email" },
+                    message: "must have required property 'email'",
+                },
+                {
+                    instancePath: "/user",
+                    schemaPath: "#/properties/user/required",
+                    keyword: "required",
+                    params: { missingProperty: "age" },
+                    message: "must have required property 'age'",
+                },
+            ];
+            const data = { user: { name: "John" } };
+
+            const formatted = formatValidationErrors(errors, data);
+
+            // Should only show the path and data once
+            const pathCount = (formatted.match(/Path: \/user/g) || []).length;
+            expect(pathCount).toBe(1);
+
+            // But should list both missing properties
+            expect(formatted).toContain('Missing required property: email');
+            expect(formatted).toContain('Missing required property: age');
+        });
+    });
 });
 
 const jsonSchemas: JSONSchema7 = {

package/src/FlinkApp.ts

@@ -19,7 +19,7 @@ import { FlinkPlugin } from "./FlinkPlugin";
 import { FlinkRepo } from "./FlinkRepo";
 import { FlinkResponse } from "./FlinkResponse";
 import generateMockData from "./mock-data-generator";
-import { getPathParams, isError } from "./utils";
+import { formatValidationErrors, getPathParams, isError } from "./utils";
 
 const ajv = new Ajv();
 addFormats(ajv);
@@ -504,9 +504,8 @@ export class FlinkApp<C extends FlinkContext> {
                     const valid = validateReq(req.body);
 
                     if (!valid) {
-                        log.warn(`${methodAndRoute}: Bad request ${JSON.stringify(validateReq.errors, null, 2)}`);
-
-                        log.debug(`Invalid json: ${JSON.stringify(req.body)}`);
+                        const formattedErrors = formatValidationErrors(validateReq.errors, req.body);
+                        log.warn(`[${req.reqId}] ${methodAndRoute}: Bad request\n${formattedErrors}`);
 
                         return res.status(400).json({
                             status: 400,
@@ -563,9 +562,8 @@ export class FlinkApp<C extends FlinkContext> {
                     const valid = validateRes(JSON.parse(JSON.stringify(handlerRes.data)));
 
                     if (!valid) {
-                        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));
+                        const formattedErrors = formatValidationErrors(validateRes.errors, handlerRes.data);
+                        log.warn(`[${req.reqId}] ${methodAndRoute}: Bad response\n${formattedErrors}`);
 
                         return res.status(500).json({
                             status: 500,

package/src/utils.ts

@@ -101,3 +101,77 @@ const pathParamsRegex = /:([a-zA-Z0-9]+)/g;
 export function getPathParams(path: string) {
     return path.match(pathParamsRegex)?.map((match) => match.slice(1)) || [];
 }
+
+/**
+ * Extracts data at a given JSON path (e.g., "/jobs/5/result")
+ * Returns the value at that path, or undefined if not found
+ */
+export function getDataAtPath(data: any, instancePath: string): any {
+    if (!instancePath || instancePath === "/") {
+        return data;
+    }
+
+    const parts = instancePath.split("/").filter((p) => p.length > 0);
+    let current = data;
+
+    for (const part of parts) {
+        if (current === undefined || current === null) {
+            return undefined;
+        }
+        current = current[part];
+    }
+
+    return current;
+}
+
+/**
+ * Formats validation errors with context about the problematic data
+ * @param errors AJV validation errors
+ * @param data The full data object that failed validation
+ * @param maxDataLength Maximum length of data to show (default 500)
+ */
+export function formatValidationErrors(errors: any[] | null | undefined, data: any, maxDataLength = 500): string {
+    if (!errors || errors.length === 0) {
+        return "Unknown validation error";
+    }
+
+    const formatted: string[] = [];
+
+    // Group errors by instance path to avoid repetition
+    const errorsByPath = new Map<string, any[]>();
+    for (const error of errors) {
+        const path = error.instancePath || "/";
+        if (!errorsByPath.has(path)) {
+            errorsByPath.set(path, []);
+        }
+        errorsByPath.get(path)!.push(error);
+    }
+
+    errorsByPath.forEach((pathErrors, path) => {
+        const dataAtPath = getDataAtPath(data, path);
+        let dataStr = JSON.stringify(dataAtPath);
+
+        // Truncate if too long
+        if (dataStr.length > maxDataLength) {
+            dataStr = dataStr.substring(0, maxDataLength) + "... (truncated)";
+        }
+
+        formatted.push(`\nPath: ${path}`);
+        formatted.push(`Data: ${dataStr}`);
+        formatted.push(`Errors:`);
+
+        for (const error of pathErrors) {
+            if (error.keyword === "required") {
+                formatted.push(`  - Missing required property: ${error.params.missingProperty}`);
+            } else if (error.keyword === "type") {
+                formatted.push(`  - Invalid type at ${error.schemaPath}: expected ${error.params.type}, got ${typeof dataAtPath}`);
+            } else if (error.keyword === "anyOf" || error.keyword === "oneOf") {
+                formatted.push(`  - ${error.message}`);
+            } else {
+                formatted.push(`  - ${error.message} (${error.keyword})`);
+            }
+        }
+    });
+
+    return formatted.join("\n");
+}