@flink-app/streaming-plugin 0.12.1-alpha.45

package/spec/StreamingPlugin.spec.ts

@@ -0,0 +1,513 @@
+import { FlinkApp, FlinkContext, FlinkAuthPlugin, FlinkRequest } from "@flink-app/flink";
+import { EventEmitter } from "events";
+import { streamingPlugin, StreamHandler, StreamingRouteProps } from "../src";
+
+interface TestContext extends FlinkContext {
+    repos: {};
+    plugins: {};
+}
+
+// Mock auth plugin
+class MockAuthPlugin implements FlinkAuthPlugin {
+    public shouldAuthenticate: boolean = true;
+
+    async authenticateRequest(req: FlinkRequest, permissions: string | string[]): Promise<boolean> {
+        // Simulate authentication check
+        const token = req.headers?.authorization;
+
+        if (!token) {
+            return false;
+        }
+
+        if (token === "Bearer valid-token") {
+            // Set user info on request
+            (req as any).user = { userId: "test-user", name: "Test User" };
+            return this.shouldAuthenticate;
+        }
+
+        return false;
+    }
+
+    createToken(userId: string): Promise<string> {
+        // Mock token creation
+        return Promise.resolve(`mock-token-${userId}`);
+    }
+}
+
+// Mock response object
+class MockResponse extends EventEmitter {
+    public headers: { [key: string]: string } = {};
+    public statusCode?: number;
+    public data: string[] = [];
+    public jsonData: any[] = [];
+    public ended = false;
+
+    setHeader(key: string, value: string) {
+        this.headers[key] = value;
+    }
+
+    status(code: number) {
+        this.statusCode = code;
+        return this;
+    }
+
+    json(data: any) {
+        this.jsonData.push(data);
+        return this;
+    }
+
+    flushHeaders() {
+        // No-op for mock
+    }
+
+    write(chunk: string) {
+        this.data.push(chunk);
+    }
+
+    end() {
+        this.ended = true;
+        this.emit("close");
+    }
+}
+
+// Mock request object
+class MockRequest {
+    public query: { [key: string]: any } = {};
+    public params: { [key: string]: any } = {};
+    public body: any = {};
+    public headers: { [key: string]: any } = {};
+
+    on(event: string, callback: () => void) {
+        // No-op for basic tests
+    }
+}
+
+describe("StreamingPlugin", () => {
+    let app: FlinkApp<TestContext>;
+    let plugin: ReturnType<typeof streamingPlugin>;
+
+    beforeEach(async () => {
+        plugin = streamingPlugin({ debug: false });
+
+        app = new FlinkApp<TestContext>({
+            name: "Test App",
+            port: 3999,
+            plugins: [plugin],
+            disableHttpServer: false,
+        });
+
+        await app.start();
+    });
+
+    afterEach(async () => {
+        await app.stop();
+    });
+
+    describe("SSE Format", () => {
+        it("should stream data in SSE format", (done) => {
+            const route: StreamingRouteProps = {
+                path: "/test-sse",
+                format: "sse",
+                skipAutoRegister: true,
+            };
+
+            const handler: StreamHandler<TestContext> = async ({ stream }) => {
+                stream.write({ message: "Hello" });
+                stream.write({ message: "World" });
+                stream.end();
+            };
+
+            plugin.registerStreamHandler(handler, route);
+
+            // Simulate request
+            const req = new MockRequest();
+            const res = new MockResponse();
+
+            // Find the registered route and call it
+            const expressApp = app.expressApp;
+            if (!expressApp) {
+                fail("Express app not initialized");
+                return;
+            }
+
+            // Make request to the endpoint
+            expressApp._router.stack.forEach((layer: any) => {
+                if (layer.route?.path === "/test-sse") {
+                    layer.route.stack[0].handle(req, res, () => {});
+                }
+            });
+
+            setTimeout(() => {
+                expect(res.headers["Content-Type"]).toBe("text/event-stream");
+                expect(res.headers["Cache-Control"]).toBe("no-cache");
+                expect(res.headers["Connection"]).toBe("keep-alive");
+                expect(res.data.length).toBe(2);
+                expect(res.data[0]).toContain('data: {"message":"Hello"}');
+                expect(res.data[1]).toContain('data: {"message":"World"}');
+                expect(res.ended).toBe(true);
+                done();
+            }, 100);
+        });
+
+        it("should send error events in SSE format", (done) => {
+            const route: StreamingRouteProps = {
+                path: "/test-sse-error",
+                format: "sse",
+                skipAutoRegister: true,
+            };
+
+            const handler: StreamHandler<TestContext> = async ({ stream }) => {
+                stream.error(new Error("Test error"));
+                stream.end();
+            };
+
+            plugin.registerStreamHandler(handler, route);
+
+            const req = new MockRequest();
+            const res = new MockResponse();
+
+            const expressApp = app.expressApp;
+            if (!expressApp) {
+                fail("Express app not initialized");
+                return;
+            }
+
+            expressApp._router.stack.forEach((layer: any) => {
+                if (layer.route?.path === "/test-sse-error") {
+                    layer.route.stack[0].handle(req, res, () => {});
+                }
+            });
+
+            setTimeout(() => {
+                expect(res.data[0]).toContain("event: error");
+                expect(res.data[0]).toContain("Test error");
+                done();
+            }, 100);
+        });
+    });
+
+    describe("NDJSON Format", () => {
+        it("should stream data in NDJSON format", (done) => {
+            const route: StreamingRouteProps = {
+                path: "/test-ndjson",
+                format: "ndjson",
+                skipAutoRegister: true,
+            };
+
+            const handler: StreamHandler<TestContext> = async ({ stream }) => {
+                stream.write({ delta: "Hello" });
+                stream.write({ delta: "World", done: true });
+                stream.end();
+            };
+
+            plugin.registerStreamHandler(handler, route);
+
+            const req = new MockRequest();
+            const res = new MockResponse();
+
+            const expressApp = app.expressApp;
+            if (!expressApp) {
+                fail("Express app not initialized");
+                return;
+            }
+
+            expressApp._router.stack.forEach((layer: any) => {
+                if (layer.route?.path === "/test-ndjson") {
+                    layer.route.stack[0].handle(req, res, () => {});
+                }
+            });
+
+            setTimeout(() => {
+                expect(res.headers["Content-Type"]).toBe("application/x-ndjson");
+                expect(res.data.length).toBe(2);
+                expect(res.data[0]).toBe('{"delta":"Hello"}\n');
+                expect(res.data[1]).toBe('{"delta":"World","done":true}\n');
+                expect(res.ended).toBe(true);
+                done();
+            }, 100);
+        });
+    });
+
+    describe("Stream Writer", () => {
+        it("should detect closed connections", (done) => {
+            const route: StreamingRouteProps = {
+                path: "/test-closed",
+                format: "sse",
+                skipAutoRegister: true,
+            };
+
+            const handler: StreamHandler<TestContext> = async ({ stream }) => {
+                expect(stream.isOpen()).toBe(true);
+                stream.end();
+                // After end, isOpen should be false (handled by plugin)
+            };
+
+            plugin.registerStreamHandler(handler, route);
+
+            const req = new MockRequest();
+            const res = new MockResponse();
+
+            const expressApp = app.expressApp;
+            if (!expressApp) {
+                fail("Express app not initialized");
+                return;
+            }
+
+            expressApp._router.stack.forEach((layer: any) => {
+                if (layer.route?.path === "/test-closed") {
+                    layer.route.stack[0].handle(req, res, () => {});
+                }
+            });
+
+            setTimeout(() => {
+                expect(res.ended).toBe(true);
+                done();
+            }, 100);
+        });
+    });
+
+    describe("Authentication", () => {
+        let appWithAuth: FlinkApp<TestContext>;
+        let pluginWithAuth: ReturnType<typeof streamingPlugin>;
+        let mockAuth: MockAuthPlugin;
+
+        beforeEach(async () => {
+            mockAuth = new MockAuthPlugin();
+            pluginWithAuth = streamingPlugin({ debug: false });
+
+            appWithAuth = new FlinkApp<TestContext>({
+                name: "Test App With Auth",
+                port: 4000,
+                plugins: [pluginWithAuth],
+                auth: mockAuth,
+                disableHttpServer: false,
+            });
+
+            await appWithAuth.start();
+        });
+
+        afterEach(async () => {
+            await appWithAuth.stop();
+        });
+
+        it("should allow authenticated requests with valid token", (done) => {
+            const route: StreamingRouteProps = {
+                path: "/test-auth-success",
+                format: "sse",
+                skipAutoRegister: true,
+                permissions: ["admin"],
+            };
+
+            const handler: StreamHandler<TestContext> = async ({ stream, req }) => {
+                const user = (req as any).user;
+                stream.write({ message: `Hello ${user?.name}` });
+                stream.end();
+            };
+
+            pluginWithAuth.registerStreamHandler(handler, route);
+
+            const req = new MockRequest();
+            req.headers.authorization = "Bearer valid-token";
+            const res = new MockResponse();
+
+            const expressApp = appWithAuth.expressApp;
+            if (!expressApp) {
+                fail("Express app not initialized");
+                return;
+            }
+
+            expressApp._router.stack.forEach((layer: any) => {
+                if (layer.route?.path === "/test-auth-success") {
+                    layer.route.stack[0].handle(req, res, () => {});
+                }
+            });
+
+            setTimeout(() => {
+                expect(res.statusCode).not.toBe(401);
+                expect(res.data.length).toBe(1);
+                expect(res.data[0]).toContain("Hello Test User");
+                expect(res.ended).toBe(true);
+                done();
+            }, 100);
+        });
+
+        it("should reject unauthenticated requests without token", (done) => {
+            const route: StreamingRouteProps = {
+                path: "/test-auth-fail-no-token",
+                format: "sse",
+                skipAutoRegister: true,
+                permissions: ["admin"],
+            };
+
+            const handler: StreamHandler<TestContext> = async ({ stream }) => {
+                stream.write({ message: "Should not see this" });
+                stream.end();
+            };
+
+            pluginWithAuth.registerStreamHandler(handler, route);
+
+            const req = new MockRequest();
+            // No authorization header
+            const res = new MockResponse();
+
+            const expressApp = appWithAuth.expressApp;
+            if (!expressApp) {
+                fail("Express app not initialized");
+                return;
+            }
+
+            expressApp._router.stack.forEach((layer: any) => {
+                if (layer.route?.path === "/test-auth-fail-no-token") {
+                    layer.route.stack[0].handle(req, res, () => {});
+                }
+            });
+
+            setTimeout(() => {
+                expect(res.statusCode).toBe(401);
+                expect(res.jsonData.length).toBe(1);
+                expect(res.jsonData[0].error.title).toBe("Unauthorized");
+                expect(res.data.length).toBe(0); // Should not stream any data
+                done();
+            }, 100);
+        });
+
+        it("should reject requests with invalid token", (done) => {
+            const route: StreamingRouteProps = {
+                path: "/test-auth-fail-invalid-token",
+                format: "sse",
+                skipAutoRegister: true,
+                permissions: ["admin"],
+            };
+
+            const handler: StreamHandler<TestContext> = async ({ stream }) => {
+                stream.write({ message: "Should not see this" });
+                stream.end();
+            };
+
+            pluginWithAuth.registerStreamHandler(handler, route);
+
+            const req = new MockRequest();
+            req.headers.authorization = "Bearer invalid-token";
+            const res = new MockResponse();
+
+            const expressApp = appWithAuth.expressApp;
+            if (!expressApp) {
+                fail("Express app not initialized");
+                return;
+            }
+
+            expressApp._router.stack.forEach((layer: any) => {
+                if (layer.route?.path === "/test-auth-fail-invalid-token") {
+                    layer.route.stack[0].handle(req, res, () => {});
+                }
+            });
+
+            setTimeout(() => {
+                expect(res.statusCode).toBe(401);
+                expect(res.jsonData.length).toBe(1);
+                expect(res.jsonData[0].error.title).toBe("Unauthorized");
+                expect(res.data.length).toBe(0);
+                done();
+            }, 100);
+        });
+
+        it("should allow streaming without permissions when no auth is required", (done) => {
+            const route: StreamingRouteProps = {
+                path: "/test-no-auth-required",
+                format: "sse",
+                skipAutoRegister: true,
+                // No permissions specified
+            };
+
+            const handler: StreamHandler<TestContext> = async ({ stream }) => {
+                stream.write({ message: "Public endpoint" });
+                stream.end();
+            };
+
+            pluginWithAuth.registerStreamHandler(handler, route);
+
+            const req = new MockRequest();
+            // No authorization header, but endpoint doesn't require it
+            const res = new MockResponse();
+
+            const expressApp = appWithAuth.expressApp;
+            if (!expressApp) {
+                fail("Express app not initialized");
+                return;
+            }
+
+            expressApp._router.stack.forEach((layer: any) => {
+                if (layer.route?.path === "/test-no-auth-required") {
+                    layer.route.stack[0].handle(req, res, () => {});
+                }
+            });
+
+            setTimeout(() => {
+                expect(res.statusCode).not.toBe(401);
+                expect(res.data.length).toBe(1);
+                expect(res.data[0]).toContain("Public endpoint");
+                expect(res.ended).toBe(true);
+                done();
+            }, 100);
+        });
+
+        it("should provide access to req.user populated by auth plugin", (done) => {
+            const route: StreamingRouteProps = {
+                path: "/test-req-user-access",
+                format: "ndjson",
+                skipAutoRegister: true,
+                permissions: ["admin"],
+            };
+
+            const handler: StreamHandler<TestContext> = async ({ stream, req }) => {
+                // Access req.user that was set by auth plugin
+                const user = (req as any).user;
+
+                // Verify user object exists and has expected properties
+                expect(user).toBeDefined();
+                expect(user.userId).toBe("test-user");
+                expect(user.name).toBe("Test User");
+
+                // Stream user info
+                stream.write({
+                    userId: user.userId,
+                    userName: user.name,
+                    message: "User info from req.user"
+                });
+                stream.end();
+            };
+
+            pluginWithAuth.registerStreamHandler(handler, route);
+
+            const req = new MockRequest();
+            req.headers.authorization = "Bearer valid-token";
+            const res = new MockResponse();
+
+            const expressApp = appWithAuth.expressApp;
+            if (!expressApp) {
+                fail("Express app not initialized");
+                return;
+            }
+
+            expressApp._router.stack.forEach((layer: any) => {
+                if (layer.route?.path === "/test-req-user-access") {
+                    layer.route.stack[0].handle(req, res, () => {});
+                }
+            });
+
+            setTimeout(() => {
+                expect(res.statusCode).not.toBe(401);
+                expect(res.data.length).toBe(1);
+
+                // Parse the NDJSON line
+                const data = JSON.parse(res.data[0].trim());
+                expect(data.userId).toBe("test-user");
+                expect(data.userName).toBe("Test User");
+                expect(data.message).toBe("User info from req.user");
+
+                expect(res.ended).toBe(true);
+                done();
+            }, 100);
+        });
+    });
+});

package/spec/support/jasmine.json

@@ -0,0 +1,7 @@
+{
+  "spec_dir": "spec",
+  "spec_files": ["**/*[sS]pec.ts"],
+  "helpers": ["helpers/**/*.ts"],
+  "stopSpecOnExpectationFailure": false,
+  "random": false
+}