@flink-app/flink 2.0.0-alpha.62 → 2.0.0-alpha.63

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @flink-app/flink
 
+## 2.0.0-alpha.63
+
+### Patch Changes
+
+-   810df2c: Fix FlinkJob afterDelay: "0ms" running in a tight loop instead of once. Zero-delay jobs now run immediately via setImmediate (exactly once) rather than being registered with a 0ms scheduler interval. Also adds specs covering uncaught exception handling for all job scheduling modes.
+-   8dd0752: fix: prevent server crash when handler returns no data with a response schema defined
+
+    When a PATCH (or any) handler returned `{ status: 204 }` without a `data` field,
+    `JSON.stringify(undefined)` returned the JS value `undefined`, causing
+    `JSON.parse(undefined)` to throw a `SyntaxError` that crashed the entire server process.
+
+    New behaviour:
+
+    -   Status 204 + no data → skip validation silently (intentional no-content response)
+    -   Non-204 status + no data + response schema defined → return 500 bad response with a
+        descriptive error message (surfaces the developer mistake without crashing the server)
+    -   Data present → validate against schema as before
+
 ## 2.0.0-alpha.62
 
 ### Minor Changes

package/dist/src/FlinkApp.js

@@ -423,7 +423,7 @@ var FlinkApp = /** @class */ (function () {
                 }
             }
             this.expressApp[method](routeProps.path, function (req, res) { return __awaiter(_this, void 0, void 0, function () {
-                var valid, formattedErrors, data, normalizedQuery, _i, _a, _b, key, value, stream, handlerRes, flinkReq_1, err_1, errorResponse, result, valid, formattedErrors;
+                var valid, formattedErrors, data, normalizedQuery, _i, _a, _b, key, value, stream, handlerRes, flinkReq_1, err_1, errorResponse, result, detail, valid, formattedErrors;
                 var _this = this;
                 return __generator(this, function (_c) {
                     switch (_c.label) {
@@ -570,18 +570,30 @@ var FlinkApp = /** @class */ (function () {
                                 return [2 /*return*/, res.status(204).send()];
                             }
                             if (validateRes_1 && !(0, utils_1.isError)(handlerRes)) {
-                                valid = validateRes_1(JSON.parse(JSON.stringify(handlerRes.data)));
-                                if (!valid) {
-                                    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: {
-                                                id: (0, uuid_1.v4)(),
-                                                title: "Bad response",
-                                                detail: formattedErrors,
-                                            },
-                                        })];
+                                if (handlerRes.data === undefined) {
+                                    if (handlerRes.status !== 204) {
+                                        detail = "Response schema is defined but handler returned no data";
+                                        FlinkLog_1.log.warn("[".concat(req.reqId, "] ").concat(methodAndRoute_1, ": Bad response - ").concat(detail));
+                                        return [2 /*return*/, res.status(500).json({
+                                                status: 500,
+                                                error: { id: (0, uuid_1.v4)(), title: "Bad response", detail: detail },
+                                            })];
+                                    }
+                                }
+                                else {
+                                    valid = validateRes_1(JSON.parse(JSON.stringify(handlerRes.data)));
+                                    if (!valid) {
+                                        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: {
+                                                    id: (0, uuid_1.v4)(),
+                                                    title: "Bad response",
+                                                    detail: formattedErrors,
+                                                },
+                                            })];
+                                    }
                                 }
                             }
                             res.set(handlerRes.headers);
@@ -901,14 +913,38 @@ var FlinkApp = /** @class */ (function () {
                         this_1.scheduler.addSimpleIntervalJob(job);
                     }
                     else if (jobProps.afterDelay !== undefined) {
-                        var job = new toad_scheduler_1.SimpleIntervalJob({
-                            milliseconds: (0, ms_1.default)(jobProps.afterDelay),
-                            runImmediately: false,
-                        }, task, {
-                            id: jobProps.id,
-                            preventOverrun: jobProps.singleton,
-                        });
-                        this_1.scheduler.addSimpleIntervalJob(job);
+                        var delayMs = (0, ms_1.default)(jobProps.afterDelay);
+                        if (delayMs === 0) {
+                            setImmediate(function () { return __awaiter(_this, void 0, void 0, function () {
+                                var err_2;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            _a.trys.push([0, 2, , 3]);
+                                            return [4 /*yield*/, jobFn({ ctx: this.ctx })];
+                                        case 1:
+                                            _a.sent();
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            err_2 = _a.sent();
+                                            FlinkLog_1.log.error("Job ".concat(jobProps.id, " threw unhandled exception ").concat(err_2));
+                                            console.error(err_2);
+                                            return [3 /*break*/, 3];
+                                        case 3: return [2 /*return*/];
+                                    }
+                                });
+                            }); });
+                        }
+                        else {
+                            var job = new toad_scheduler_1.SimpleIntervalJob({
+                                milliseconds: delayMs,
+                                runImmediately: false,
+                            }, task, {
+                                id: jobProps.id,
+                                preventOverrun: jobProps.singleton,
+                            });
+                            this_1.scheduler.addSimpleIntervalJob(job);
+                        }
                     }
                     else {
                         FlinkLog_1.log.error("Cannot register job ".concat(jobProps.id, " - no cron, interval or once set in ").concat(__file));
@@ -1111,7 +1147,7 @@ var FlinkApp = /** @class */ (function () {
      */
     FlinkApp.prototype.initDb = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var client, err_2;
+            var client, err_3;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -1127,8 +1163,8 @@ var FlinkApp = /** @class */ (function () {
                         this.dbClient = client;
                         return [3 /*break*/, 4];
                     case 3:
-                        err_2 = _a.sent();
-                        FlinkLog_1.log.error("Failed to connect to db: " + err_2);
+                        err_3 = _a.sent();
+                        FlinkLog_1.log.error("Failed to connect to db: " + err_3);
                         process.exit(1);
                         return [3 /*break*/, 4];
                     case 4:
@@ -1147,7 +1183,7 @@ var FlinkApp = /** @class */ (function () {
      */
     FlinkApp.prototype.initPluginDb = function (plugin) {
         return __awaiter(this, void 0, void 0, function () {
-            var client, err_3;
+            var client, err_4;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -1174,8 +1210,8 @@ var FlinkApp = /** @class */ (function () {
                         client = _a.sent();
                         return [2 /*return*/, client.db()];
                     case 4:
-                        err_3 = _a.sent();
-                        FlinkLog_1.log.error("Failed to connect to db defined in plugin '".concat(plugin.id, "': ") + err_3);
+                        err_4 = _a.sent();
+                        FlinkLog_1.log.error("Failed to connect to db defined in plugin '".concat(plugin.id, "': ") + err_4);
                         return [3 /*break*/, 5];
                     case 5: return [2 /*return*/];
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flink-app/flink",
-  "version": "2.0.0-alpha.62",
+  "version": "2.0.0-alpha.63",
   "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/FlinkApp.undefinedResponse.spec.ts

@@ -0,0 +1,123 @@
+import { FlinkApp } from "../src/FlinkApp";
+import { FlinkContext } from "../src/FlinkContext";
+import { GetHandler, Handler, HttpMethod } from "../src/FlinkHttpHandler";
+
+const request = require("supertest");
+
+interface TestContext extends FlinkContext {}
+
+const resSchema = {
+    type: "object",
+    properties: {
+        id: { type: "string" },
+    },
+    required: ["id"],
+};
+
+describe("FlinkApp response validation when handler returns no data", () => {
+    let app: FlinkApp<TestContext>;
+
+    afterEach(async () => {
+        if (app && app.started) {
+            await app.stop();
+        }
+    });
+
+    it("should return 500 bad response when handler returns undefined data with a response schema", async () => {
+        const handler: GetHandler<TestContext, any> = async () => {
+            return { status: 200 } as any; // no data
+        };
+
+        app = new FlinkApp<TestContext>({ name: "test-undefined-data", port: 4200 });
+        await app.start();
+
+        app.addHandler({
+            default: handler,
+            Route: { method: HttpMethod.get, path: "/test", resSchema },
+        });
+
+        const response = await request(app.expressApp).get("/test");
+
+        expect(response.status).toBe(500);
+        expect(response.body.error.title).toBe("Bad response");
+        expect(response.body.error.detail).toContain("no data");
+    });
+
+    it("should NOT return 500 when handler returns status 204 with no data (even if schema is defined)", async () => {
+        const handler: Handler<TestContext, any, any> = async () => {
+            return { status: 204 } as any;
+        };
+
+        app = new FlinkApp<TestContext>({ name: "test-204-no-data", port: 4201 });
+        await app.start();
+
+        app.addHandler({
+            default: handler,
+            Route: { method: HttpMethod.patch, path: "/test", resSchema },
+        });
+
+        const response = await request(app.expressApp).patch("/test");
+
+        expect(response.status).toBe(204);
+    });
+
+    it("should validate normally when handler returns valid data", async () => {
+        const handler: GetHandler<TestContext, any> = async () => {
+            return { data: { id: "abc-123" } };
+        };
+
+        app = new FlinkApp<TestContext>({ name: "test-valid-data", port: 4202 });
+        await app.start();
+
+        app.addHandler({
+            default: handler,
+            Route: { method: HttpMethod.get, path: "/test", resSchema },
+        });
+
+        const response = await request(app.expressApp).get("/test");
+
+        expect(response.status).toBe(200);
+        expect(response.body.data.id).toBe("abc-123");
+    });
+
+    it("should return 500 bad response when handler returns invalid data against schema", async () => {
+        const handler: GetHandler<TestContext, any> = async () => {
+            return { data: { wrongField: 123 } }; // missing required "id"
+        };
+
+        app = new FlinkApp<TestContext>({ name: "test-invalid-data", port: 4203 });
+        await app.start();
+
+        app.addHandler({
+            default: handler,
+            Route: { method: HttpMethod.get, path: "/test", resSchema },
+        });
+
+        const response = await request(app.expressApp).get("/test");
+
+        expect(response.status).toBe(500);
+        expect(response.body.error.title).toBe("Bad response");
+    });
+
+    it("should not crash the server when handler returns undefined data", async () => {
+        const handler: GetHandler<TestContext, any> = async () => {
+            return { status: 200 } as any;
+        };
+
+        app = new FlinkApp<TestContext>({ name: "test-no-crash", port: 4204 });
+        await app.start();
+
+        app.addHandler({
+            default: handler,
+            Route: { method: HttpMethod.get, path: "/test", resSchema },
+        });
+
+        // First request triggers the bad response
+        await request(app.expressApp).get("/test");
+
+        // Server should still be running and able to handle further requests
+        const second = await request(app.expressApp).get("/test");
+        expect(second.status).toBe(500); // still returns 500, but doesn't crash
+        expect(app.started).toBe(true);
+    });
+});

package/spec/FlinkJob.spec.ts

@@ -0,0 +1,95 @@
+import { FlinkApp, autoRegisteredJobs } from "../src/FlinkApp";
+import { FlinkContext } from "../src/FlinkContext";
+import { FlinkJobFile } from "../src/FlinkJob";
+
+interface TestContext extends FlinkContext {}
+
+describe("FlinkJob error handling", () => {
+    let app: FlinkApp<TestContext>;
+    let consoleErrorSpy: jasmine.Spy;
+
+    beforeEach(() => {
+        consoleErrorSpy = spyOn(console, "error");
+    });
+
+    afterEach(async () => {
+        autoRegisteredJobs.length = 0;
+        if (app?.started) {
+            await app.stop();
+        }
+    });
+
+    it("should catch and log errors from afterDelay 0ms jobs without crashing", async () => {
+        const job: FlinkJobFile = {
+            Job: { id: "failing-job-0ms", afterDelay: "0ms" },
+            default: async () => {
+                throw new Error("Job error 0ms");
+            },
+        };
+
+        autoRegisteredJobs.push(job);
+
+        app = new FlinkApp<TestContext>({ name: "test-job-errors-0ms", disableHttpServer: true });
+        await app.start();
+
+        await new Promise((resolve) => setTimeout(resolve, 50));
+
+        expect(consoleErrorSpy).toHaveBeenCalled();
+    });
+
+    it("should catch and log errors from afterDelay jobs without crashing", async () => {
+        const job: FlinkJobFile = {
+            Job: { id: "failing-job-delay", afterDelay: "10ms" },
+            default: async () => {
+                throw new Error("Job error with delay");
+            },
+        };
+
+        autoRegisteredJobs.push(job);
+
+        app = new FlinkApp<TestContext>({ name: "test-job-errors-delay", disableHttpServer: true });
+        await app.start();
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        expect(consoleErrorSpy).toHaveBeenCalled();
+    });
+
+    it("should catch and log errors from interval jobs without crashing", async () => {
+        const job: FlinkJobFile = {
+            Job: { id: "failing-interval-job", interval: "10ms" },
+            default: async () => {
+                throw new Error("Interval job error");
+            },
+        };
+
+        autoRegisteredJobs.push(job);
+
+        app = new FlinkApp<TestContext>({ name: "test-job-errors-interval", disableHttpServer: true });
+        await app.start();
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        expect(consoleErrorSpy).toHaveBeenCalled();
+    });
+
+    it("should run afterDelay 0ms job exactly once", async () => {
+        let runCount = 0;
+
+        const job: FlinkJobFile = {
+            Job: { id: "once-job-0ms", afterDelay: "0ms" },
+            default: async () => {
+                runCount++;
+            },
+        };
+
+        autoRegisteredJobs.push(job);
+
+        app = new FlinkApp<TestContext>({ name: "test-job-once-0ms", disableHttpServer: true });
+        await app.start();
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        expect(runCount).toBe(1);
+    });
+});

package/src/FlinkApp.ts

@@ -790,20 +790,32 @@ export class FlinkApp<C extends FlinkContext> {
                 }
 
                 if (validateRes && !isError(handlerRes)) {
-                    const valid = validateRes(JSON.parse(JSON.stringify(handlerRes.data)));
-
-                    if (!valid) {
-                        const formattedErrors = formatValidationErrors(validateRes.errors, handlerRes.data);
-                        log.warn(`[${req.reqId}] ${methodAndRoute}: Bad response\n${formattedErrors}`);
-
-                        return res.status(500).json({
-                            status: 500,
-                            error: {
-                                id: v4(),
-                                title: "Bad response",
-                                detail: formattedErrors,
-                            },
-                        });
+                    if (handlerRes.data === undefined) {
+                        if (handlerRes.status !== 204) {
+                            const detail =
+                                "Response schema is defined but handler returned no data";
+                            log.warn(`[${req.reqId}] ${methodAndRoute}: Bad response - ${detail}`);
+                            return res.status(500).json({
+                                status: 500,
+                                error: { id: v4(), title: "Bad response", detail },
+                            });
+                        }
+                    } else {
+                        const valid = validateRes(JSON.parse(JSON.stringify(handlerRes.data)));
+
+                        if (!valid) {
+                            const formattedErrors = formatValidationErrors(validateRes.errors, handlerRes.data);
+                            log.warn(`[${req.reqId}] ${methodAndRoute}: Bad response\n${formattedErrors}`);
+
+                            return res.status(500).json({
+                                status: 500,
+                                error: {
+                                    id: v4(),
+                                    title: "Bad response",
+                                    detail: formattedErrors,
+                                },
+                            });
+                        }
                     }
                 }
 
@@ -1198,18 +1210,30 @@ export class FlinkApp<C extends FlinkContext> {
 
                 this.scheduler.addSimpleIntervalJob(job);
             } else if (jobProps.afterDelay !== undefined) {
-                const job = new SimpleIntervalJob(
-                    {
-                        milliseconds: ms(jobProps.afterDelay),
-                        runImmediately: false,
-                    },
-                    task,
-                    {
-                        id: jobProps.id,
-                        preventOverrun: jobProps.singleton,
-                    }
-                );
-                this.scheduler.addSimpleIntervalJob(job);
+                const delayMs = ms(jobProps.afterDelay);
+                if (delayMs === 0) {
+                    setImmediate(async () => {
+                        try {
+                            await jobFn({ ctx: this.ctx });
+                        } catch (err) {
+                            log.error(`Job ${jobProps.id} threw unhandled exception ${err}`);
+                            console.error(err);
+                        }
+                    });
+                } else {
+                    const job = new SimpleIntervalJob(
+                        {
+                            milliseconds: delayMs,
+                            runImmediately: false,
+                        },
+                        task,
+                        {
+                            id: jobProps.id,
+                            preventOverrun: jobProps.singleton,
+                        }
+                    );
+                    this.scheduler.addSimpleIntervalJob(job);
+                }
             } else {
                 log.error(`Cannot register job ${jobProps.id} - no cron, interval or once set in ${__file}`);
                 continue;