@flink-app/flink 0.14.3 → 2.0.0-alpha.100

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/FlinkApp.validationMode.spec.ts

@@ -0,0 +1,155 @@
+import { FlinkApp } from "../src/FlinkApp";
+import { FlinkContext } from "../src/FlinkContext";
+import { Handler, RouteProps, ValidationMode } from "../src/FlinkHttpHandler";
+
+interface TestContext extends FlinkContext {}
+
+// Test schemas
+interface ValidRequest {
+    name: string;
+    age: number;
+}
+
+interface ValidResponse {
+    message: string;
+    status: string;
+}
+
+describe("FlinkApp validation modes", () => {
+    let app: FlinkApp<TestContext>;
+
+    beforeEach(async () => {
+        app = new FlinkApp<TestContext>({
+            name: "validation-test-app",
+            debug: false,
+        });
+    });
+
+    afterEach(async () => {
+        if (app && app.started) {
+            await app.stop();
+        }
+    });
+
+    describe("ValidationMode enum", () => {
+        it("should have all validation mode values", () => {
+            expect(ValidationMode.Validate).toBe("Validate");
+            expect(ValidationMode.SkipValidation).toBe("SkipValidation");
+            expect(ValidationMode.ValidateRequest).toBe("ValidateRequest");
+            expect(ValidationMode.ValidateResponse).toBe("ValidateResponse");
+        });
+    });
+
+    describe("RouteProps validation property", () => {
+        it("should accept validation property with ValidationMode.Validate", () => {
+            const route: RouteProps = {
+                path: "/test",
+                validation: ValidationMode.Validate,
+            };
+
+            expect(route.validation).toBe(ValidationMode.Validate);
+        });
+
+        it("should accept validation property with ValidationMode.SkipValidation", () => {
+            const route: RouteProps = {
+                path: "/test",
+                validation: ValidationMode.SkipValidation,
+            };
+
+            expect(route.validation).toBe(ValidationMode.SkipValidation);
+        });
+
+        it("should accept validation property with ValidationMode.ValidateRequest", () => {
+            const route: RouteProps = {
+                path: "/test",
+                validation: ValidationMode.ValidateRequest,
+            };
+
+            expect(route.validation).toBe(ValidationMode.ValidateRequest);
+        });
+
+        it("should accept validation property with ValidationMode.ValidateResponse", () => {
+            const route: RouteProps = {
+                path: "/test",
+                validation: ValidationMode.ValidateResponse,
+            };
+
+            expect(route.validation).toBe(ValidationMode.ValidateResponse);
+        });
+
+        it("should be optional and default to undefined", () => {
+            const route: RouteProps = {
+                path: "/test",
+            };
+
+            expect(route.validation).toBeUndefined();
+        });
+    });
+
+    describe("Handler type compatibility", () => {
+        it("should allow handlers with validation modes to compile", () => {
+            // This test verifies TypeScript compilation
+
+            const handler: Handler<TestContext, ValidRequest, ValidResponse> = async ({ ctx, req }) => {
+                return {
+                    status: 200,
+                    data: {
+                        message: "success",
+                        status: "ok",
+                    },
+                };
+            };
+
+            expect(handler).toBeDefined();
+            expect(typeof handler).toBe("function");
+        });
+
+        it("should allow route props with different validation modes", () => {
+            const routes: RouteProps[] = [
+                { path: "/test1", validation: ValidationMode.Validate },
+                { path: "/test2", validation: ValidationMode.SkipValidation },
+                { path: "/test3", validation: ValidationMode.ValidateRequest },
+                { path: "/test4", validation: ValidationMode.ValidateResponse },
+                { path: "/test5" }, // No validation specified
+            ];
+
+            expect(routes.length).toBe(5);
+            expect(routes[0].validation).toBe(ValidationMode.Validate);
+            expect(routes[1].validation).toBe(ValidationMode.SkipValidation);
+            expect(routes[2].validation).toBe(ValidationMode.ValidateRequest);
+            expect(routes[3].validation).toBe(ValidationMode.ValidateResponse);
+            expect(routes[4].validation).toBeUndefined();
+        });
+    });
+
+    describe("Backward compatibility", () => {
+        it("should not break existing code without validation property", () => {
+            const route: RouteProps = {
+                path: "/legacy",
+                permissions: ["admin"],
+            };
+
+            // TypeScript should compile this without errors
+            expect(route.path).toBe("/legacy");
+            expect(route.validation).toBeUndefined();
+        });
+
+        it("should allow all existing RouteProps properties with validation", () => {
+            const route: RouteProps = {
+                path: "/test",
+                permissions: ["admin", "user"],
+                skipAutoRegister: true,
+                docs: "Test endpoint",
+                order: -1,
+                validation: ValidationMode.SkipValidation,
+            };
+
+            expect(route.path).toBe("/test");
+            expect(route.permissions).toEqual(["admin", "user"]);
+            expect(route.skipAutoRegister).toBe(true);
+            expect(route.docs).toBe("Test endpoint");
+            expect(route.order).toBe(-1);
+            expect(route.validation).toBe(ValidationMode.SkipValidation);
+        });
+    });
+});

package/spec/FlinkJob.spec.ts

@@ -0,0 +1,171 @@
+import { FlinkApp, autoRegisteredJobs } from "../src/FlinkApp";
+import { FlinkContext } from "../src/FlinkContext";
+import { FlinkJobFile } from "../src/FlinkJob";
+import { FlinkLogFactory } from "../src/FlinkLogFactory";
+
+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);
+    });
+});
+
+describe("FlinkJob leader election with runOnAllInstances", () => {
+    let app: FlinkApp<TestContext>;
+
+    afterEach(async () => {
+        autoRegisteredJobs.length = 0;
+        if (app?.started) {
+            await app.stop();
+        }
+    });
+
+    it("should run all jobs when leader election is enabled but no db is configured", async () => {
+        const schedulerLog = FlinkLogFactory.createLogger("flink.scheduler");
+        const warnSpy = spyOn(schedulerLog, "warn");
+
+        let leaderJobRan = false;
+        let allInstanceJobRan = false;
+
+        autoRegisteredJobs.push({
+            Job: { id: "leader-only-job", afterDelay: "0ms" },
+            default: async () => {
+                leaderJobRan = true;
+            },
+        });
+
+        autoRegisteredJobs.push({
+            Job: { id: "all-instance-job", afterDelay: "0ms", runOnAllInstances: true },
+            default: async () => {
+                allInstanceJobRan = true;
+            },
+        });
+
+        app = new FlinkApp<TestContext>({
+            name: "test-leader-no-db",
+            disableHttpServer: true,
+            scheduling: { leaderElection: true },
+        });
+
+        await app.start();
+        await new Promise((resolve) => setTimeout(resolve, 50));
+
+        // Without db, falls back to running all jobs
+        expect(leaderJobRan).toBe(true);
+        expect(allInstanceJobRan).toBe(true);
+        expect(warnSpy).toHaveBeenCalled();
+        const warnMessage = warnSpy.calls.mostRecent().args[0];
+        expect(warnMessage).toContain("Leader election is enabled but no database is configured");
+    });
+
+    it("should not start scheduler for leader-only jobs when not leader", async () => {
+        // Without a real MongoDB, we can't fully test leader election.
+        // This test verifies that when leaderElection is enabled without db,
+        // the warning is shown and all jobs still run as a fallback.
+        let jobRanCount = 0;
+
+        autoRegisteredJobs.push({
+            Job: { id: "interval-job", interval: "50ms" },
+            default: async () => {
+                jobRanCount++;
+            },
+        });
+
+        app = new FlinkApp<TestContext>({
+            name: "test-no-db-fallback",
+            disableHttpServer: true,
+            scheduling: { leaderElection: true },
+        });
+
+        await app.start();
+        await new Promise((resolve) => setTimeout(resolve, 200));
+
+        // Should have run at least once since it falls back without db
+        expect(jobRanCount).toBeGreaterThan(0);
+    });
+});