@flink-app/generic-request-plugin 0.12.1-alpha.45 → 0.12.1-alpha.47

package/dist/spec/GenericRequestPlugin.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/spec/GenericRequestPlugin.spec.js

@@ -0,0 +1,494 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var index_1 = require("../src/index");
+describe("GenericRequestPlugin", function () {
+    var mockApp;
+    var mockExpressApp;
+    var mockAuth;
+    var registeredRoutes;
+    beforeEach(function () {
+        registeredRoutes = new Map();
+        // Mock Express app
+        mockExpressApp = {
+            get: jasmine.createSpy("get").and.callFake(function (path, handler) {
+                registeredRoutes.set("GET:".concat(path), handler);
+            }),
+            post: jasmine.createSpy("post").and.callFake(function (path, handler) {
+                registeredRoutes.set("POST:".concat(path), handler);
+            }),
+            put: jasmine.createSpy("put").and.callFake(function (path, handler) {
+                registeredRoutes.set("PUT:".concat(path), handler);
+            }),
+            delete: jasmine.createSpy("delete").and.callFake(function (path, handler) {
+                registeredRoutes.set("DELETE:".concat(path), handler);
+            }),
+        };
+        // Mock auth plugin
+        mockAuth = {
+            authenticateRequest: jasmine.createSpy("authenticateRequest").and.returnValue(Promise.resolve(true)),
+            createToken: jasmine.createSpy("createToken").and.returnValue(Promise.resolve("token")),
+        };
+        // Mock FlinkApp
+        mockApp = {
+            expressApp: mockExpressApp,
+            auth: mockAuth,
+        };
+    });
+    describe("Plugin Registration", function () {
+        it("should create a valid plugin", function () {
+            var plugin = (0, index_1.genericRequestPlugin)({
+                path: "/test",
+                method: index_1.HttpMethod.get,
+                handler: function () { },
+            });
+            expect(plugin).toBeDefined();
+            expect(plugin.id).toBe("genericRequestPlugin");
+            expect(plugin.init).toBeDefined();
+        });
+        it("should throw error if Express app is not initialized", function () {
+            var appWithoutExpress = { expressApp: null };
+            var plugin = (0, index_1.genericRequestPlugin)({
+                path: "/test",
+                method: index_1.HttpMethod.get,
+                handler: function () { },
+            });
+            expect(function () { return plugin.init(appWithoutExpress); }).toThrowError("Express app not initialized");
+        });
+        it("should register GET route", function () {
+            var plugin = (0, index_1.genericRequestPlugin)({
+                path: "/test",
+                method: index_1.HttpMethod.get,
+                handler: function () { },
+            });
+            plugin.init(mockApp);
+            expect(mockExpressApp.get).toHaveBeenCalledWith("/test", jasmine.any(Function));
+        });
+        it("should register POST route", function () {
+            var plugin = (0, index_1.genericRequestPlugin)({
+                path: "/webhook",
+                method: index_1.HttpMethod.post,
+                handler: function () { },
+            });
+            plugin.init(mockApp);
+            expect(mockExpressApp.post).toHaveBeenCalledWith("/webhook", jasmine.any(Function));
+        });
+        it("should register PUT route", function () {
+            var plugin = (0, index_1.genericRequestPlugin)({
+                path: "/update",
+                method: index_1.HttpMethod.put,
+                handler: function () { },
+            });
+            plugin.init(mockApp);
+            expect(mockExpressApp.put).toHaveBeenCalledWith("/update", jasmine.any(Function));
+        });
+        it("should register DELETE route", function () {
+            var plugin = (0, index_1.genericRequestPlugin)({
+                path: "/remove",
+                method: index_1.HttpMethod.delete,
+                handler: function () { },
+            });
+            plugin.init(mockApp);
+            expect(mockExpressApp.delete).toHaveBeenCalledWith("/remove", jasmine.any(Function));
+        });
+    });
+    describe("Handler Execution - No Permissions", function () {
+        it("should call handler directly when no permissions are set", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var handlerSpy, plugin, routeHandler, mockReq, mockRes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        handlerSpy = jasmine.createSpy("handler");
+                        plugin = (0, index_1.genericRequestPlugin)({
+                            path: "/public",
+                            method: index_1.HttpMethod.get,
+                            handler: handlerSpy,
+                        });
+                        plugin.init(mockApp);
+                        routeHandler = registeredRoutes.get("GET:/public");
+                        if (!routeHandler) {
+                            fail("Route handler not registered");
+                            return [2 /*return*/];
+                        }
+                        mockReq = {};
+                        mockRes = {};
+                        return [4 /*yield*/, routeHandler(mockReq, mockRes)];
+                    case 1:
+                        _a.sent();
+                        expect(handlerSpy).toHaveBeenCalledWith(mockReq, mockRes, mockApp);
+                        expect(mockAuth.authenticateRequest).not.toHaveBeenCalled();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("should pass req, res, and app to handler", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var capturedReq, capturedRes, capturedApp, handler, plugin, routeHandler, mockReq, mockRes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        handler = function (req, res, app) {
+                            capturedReq = req;
+                            capturedRes = res;
+                            capturedApp = app;
+                        };
+                        plugin = (0, index_1.genericRequestPlugin)({
+                            path: "/test",
+                            method: index_1.HttpMethod.get,
+                            handler: handler,
+                        });
+                        plugin.init(mockApp);
+                        routeHandler = registeredRoutes.get("GET:/test");
+                        if (!routeHandler) {
+                            fail("Route handler not registered");
+                            return [2 /*return*/];
+                        }
+                        mockReq = { path: "/test" };
+                        mockRes = { status: function () { return ({ json: function () { } }); } };
+                        return [4 /*yield*/, routeHandler(mockReq, mockRes)];
+                    case 1:
+                        _a.sent();
+                        expect(capturedReq).toBe(mockReq);
+                        expect(capturedRes).toBe(mockRes);
+                        expect(capturedApp).toBe(mockApp);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe("Permission Validation", function () {
+        it("should validate permissions when set", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var handlerSpy, plugin, routeHandler, mockReq, mockRes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        handlerSpy = jasmine.createSpy("handler");
+                        plugin = (0, index_1.genericRequestPlugin)({
+                            path: "/protected",
+                            method: index_1.HttpMethod.get,
+                            permissions: "read",
+                            handler: handlerSpy,
+                        });
+                        plugin.init(mockApp);
+                        routeHandler = registeredRoutes.get("GET:/protected");
+                        if (!routeHandler) {
+                            fail("Route handler not registered");
+                            return [2 /*return*/];
+                        }
+                        mockReq = {};
+                        mockRes = {};
+                        return [4 /*yield*/, routeHandler(mockReq, mockRes)];
+                    case 1:
+                        _a.sent();
+                        expect(mockAuth.authenticateRequest).toHaveBeenCalledWith(mockReq, "read");
+                        expect(handlerSpy).toHaveBeenCalled();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("should validate multiple permissions", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var handlerSpy, plugin, routeHandler, mockReq, mockRes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        handlerSpy = jasmine.createSpy("handler");
+                        plugin = (0, index_1.genericRequestPlugin)({
+                            path: "/admin",
+                            method: index_1.HttpMethod.post,
+                            permissions: ["read", "write", "admin"],
+                            handler: handlerSpy,
+                        });
+                        plugin.init(mockApp);
+                        routeHandler = registeredRoutes.get("POST:/admin");
+                        if (!routeHandler) {
+                            fail("Route handler not registered");
+                            return [2 /*return*/];
+                        }
+                        mockReq = {};
+                        mockRes = {};
+                        return [4 /*yield*/, routeHandler(mockReq, mockRes)];
+                    case 1:
+                        _a.sent();
+                        expect(mockAuth.authenticateRequest).toHaveBeenCalledWith(mockReq, ["read", "write", "admin"]);
+                        expect(handlerSpy).toHaveBeenCalled();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("should return 401 when authentication fails", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var handlerSpy, plugin, routeHandler, mockReq, mockJsonSpy, mockRes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mockAuth.authenticateRequest = jasmine.createSpy("authenticateRequest").and.returnValue(Promise.resolve(false));
+                        handlerSpy = jasmine.createSpy("handler");
+                        plugin = (0, index_1.genericRequestPlugin)({
+                            path: "/protected",
+                            method: index_1.HttpMethod.get,
+                            permissions: "read",
+                            handler: handlerSpy,
+                        });
+                        plugin.init(mockApp);
+                        routeHandler = registeredRoutes.get("GET:/protected");
+                        if (!routeHandler) {
+                            fail("Route handler not registered");
+                            return [2 /*return*/];
+                        }
+                        mockReq = {};
+                        mockJsonSpy = jasmine.createSpy("json");
+                        mockRes = {
+                            status: jasmine.createSpy("status").and.returnValue({ json: mockJsonSpy }),
+                        };
+                        return [4 /*yield*/, routeHandler(mockReq, mockRes)];
+                    case 1:
+                        _a.sent();
+                        expect(mockAuth.authenticateRequest).toHaveBeenCalledWith(mockReq, "read");
+                        expect(mockRes.status).toHaveBeenCalledWith(401);
+                        expect(mockJsonSpy).toHaveBeenCalledWith({
+                            status: 401,
+                            error: {
+                                title: "Unauthorized",
+                                detail: "Authentication required or insufficient permissions",
+                            },
+                        });
+                        expect(handlerSpy).not.toHaveBeenCalled();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("should not call handler when authentication fails", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var handlerSpy, plugin, routeHandler, mockReq, mockRes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mockAuth.authenticateRequest = jasmine.createSpy("authenticateRequest").and.returnValue(Promise.resolve(false));
+                        handlerSpy = jasmine.createSpy("handler");
+                        plugin = (0, index_1.genericRequestPlugin)({
+                            path: "/protected",
+                            method: index_1.HttpMethod.post,
+                            permissions: "write",
+                            handler: handlerSpy,
+                        });
+                        plugin.init(mockApp);
+                        routeHandler = registeredRoutes.get("POST:/protected");
+                        if (!routeHandler) {
+                            fail("Route handler not registered");
+                            return [2 /*return*/];
+                        }
+                        mockReq = {};
+                        mockRes = {
+                            status: function () { return ({ json: function () { } }); },
+                        };
+                        return [4 /*yield*/, routeHandler(mockReq, mockRes)];
+                    case 1:
+                        _a.sent();
+                        expect(handlerSpy).not.toHaveBeenCalled();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("should throw error if permissions are set but no auth plugin is configured", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var appWithoutAuth, plugin, routeHandler, mockReq, mockRes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        appWithoutAuth = {
+                            expressApp: mockExpressApp,
+                            auth: null,
+                        };
+                        plugin = (0, index_1.genericRequestPlugin)({
+                            path: "/protected",
+                            method: index_1.HttpMethod.get,
+                            permissions: "read",
+                            handler: function () { },
+                        });
+                        plugin.init(appWithoutAuth);
+                        routeHandler = registeredRoutes.get("GET:/protected");
+                        if (!routeHandler) {
+                            fail("Route handler not registered");
+                            return [2 /*return*/];
+                        }
+                        mockReq = {};
+                        mockRes = {};
+                        return [4 /*yield*/, expectAsync(routeHandler(mockReq, mockRes)).toBeRejectedWithError("Route GET /protected requires permissions but no auth plugin is configured")];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("should call handler after successful authentication", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var handlerSpy, plugin, routeHandler, mockReq, mockRes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mockAuth.authenticateRequest = jasmine.createSpy("authenticateRequest").and.callFake(function (req) {
+                            req.user = { id: "123", username: "testuser" };
+                            return Promise.resolve(true);
+                        });
+                        handlerSpy = jasmine.createSpy("handler");
+                        plugin = (0, index_1.genericRequestPlugin)({
+                            path: "/protected",
+                            method: index_1.HttpMethod.get,
+                            permissions: "read",
+                            handler: handlerSpy,
+                        });
+                        plugin.init(mockApp);
+                        routeHandler = registeredRoutes.get("GET:/protected");
+                        if (!routeHandler) {
+                            fail("Route handler not registered");
+                            return [2 /*return*/];
+                        }
+                        mockReq = {};
+                        mockRes = {};
+                        return [4 /*yield*/, routeHandler(mockReq, mockRes)];
+                    case 1:
+                        _a.sent();
+                        expect(mockAuth.authenticateRequest).toHaveBeenCalled();
+                        expect(mockReq.user).toEqual({ id: "123", username: "testuser" });
+                        expect(handlerSpy).toHaveBeenCalledWith(mockReq, mockRes, mockApp);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe("Wildcard Permission", function () {
+        it("should validate wildcard permission for any authenticated user", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var handlerSpy, plugin, routeHandler, mockReq, mockRes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        handlerSpy = jasmine.createSpy("handler");
+                        plugin = (0, index_1.genericRequestPlugin)({
+                            path: "/authenticated",
+                            method: index_1.HttpMethod.get,
+                            permissions: "*",
+                            handler: handlerSpy,
+                        });
+                        plugin.init(mockApp);
+                        routeHandler = registeredRoutes.get("GET:/authenticated");
+                        if (!routeHandler) {
+                            fail("Route handler not registered");
+                            return [2 /*return*/];
+                        }
+                        mockReq = {};
+                        mockRes = {};
+                        return [4 /*yield*/, routeHandler(mockReq, mockRes)];
+                    case 1:
+                        _a.sent();
+                        expect(mockAuth.authenticateRequest).toHaveBeenCalledWith(mockReq, "*");
+                        expect(handlerSpy).toHaveBeenCalled();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe("Real-world Scenarios", function () {
+        it("should handle webhook with permissions", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var webhookData, webhookHandler, plugin, routeHandler, mockReq, mockJsonSpy, mockRes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        webhookHandler = function (req, res) {
+                            webhookData = req.body;
+                            res.json({ received: true });
+                        };
+                        plugin = (0, index_1.genericRequestPlugin)({
+                            path: "/webhook/stripe",
+                            method: index_1.HttpMethod.post,
+                            permissions: "webhook:stripe",
+                            handler: webhookHandler,
+                        });
+                        plugin.init(mockApp);
+                        routeHandler = registeredRoutes.get("POST:/webhook/stripe");
+                        if (!routeHandler) {
+                            fail("Route handler not registered");
+                            return [2 /*return*/];
+                        }
+                        mockReq = { body: { event: "payment.success" } };
+                        mockJsonSpy = jasmine.createSpy("json");
+                        mockRes = { json: mockJsonSpy };
+                        return [4 /*yield*/, routeHandler(mockReq, mockRes)];
+                    case 1:
+                        _a.sent();
+                        expect(mockAuth.authenticateRequest).toHaveBeenCalledWith(mockReq, "webhook:stripe");
+                        expect(webhookData).toEqual({ event: "payment.success" });
+                        expect(mockJsonSpy).toHaveBeenCalledWith({ received: true });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("should handle file download with permissions", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var fileHandler, plugin, routeHandler, mockReq, mockSetHeaderSpy, mockEndSpy, mockRes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        fileHandler = function (req, res) {
+                            res.setHeader("Content-Type", "application/pdf");
+                            res.end("file-data");
+                        };
+                        plugin = (0, index_1.genericRequestPlugin)({
+                            path: "/download/:fileId",
+                            method: index_1.HttpMethod.get,
+                            permissions: "file:download",
+                            handler: fileHandler,
+                        });
+                        plugin.init(mockApp);
+                        routeHandler = registeredRoutes.get("GET:/download/:fileId");
+                        if (!routeHandler) {
+                            fail("Route handler not registered");
+                            return [2 /*return*/];
+                        }
+                        mockReq = { params: { fileId: "123" } };
+                        mockSetHeaderSpy = jasmine.createSpy("setHeader");
+                        mockEndSpy = jasmine.createSpy("end");
+                        mockRes = {
+                            setHeader: mockSetHeaderSpy,
+                            end: mockEndSpy,
+                        };
+                        return [4 /*yield*/, routeHandler(mockReq, mockRes)];
+                    case 1:
+                        _a.sent();
+                        expect(mockAuth.authenticateRequest).toHaveBeenCalledWith(mockReq, "file:download");
+                        expect(mockSetHeaderSpy).toHaveBeenCalledWith("Content-Type", "application/pdf");
+                        expect(mockEndSpy).toHaveBeenCalledWith("file-data");
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});

package/dist/{index.d.ts → src/index.d.ts}

@@ -18,5 +18,11 @@ export type GenericRequestOptions = {
      * Http method for this request
      */
     method: HttpMethod;
+    /**
+     * Optional permission(s) required to access this route.
+     * If set, the auth plugin will validate the request before calling the handler.
+     * Requires an auth plugin (e.g., jwt-auth-plugin) to be configured in FlinkApp.
+     */
+    permissions?: string | string[];
 };
 export declare const genericRequestPlugin: (options: GenericRequestOptions) => FlinkPlugin;

package/dist/src/index.js

@@ -0,0 +1,94 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genericRequestPlugin = exports.HttpMethod = void 0;
+var node_color_log_1 = __importDefault(require("node-color-log"));
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["get"] = "get";
+    HttpMethod["post"] = "post";
+    HttpMethod["put"] = "put";
+    HttpMethod["delete"] = "delete";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+var genericRequestPlugin = function (options) {
+    return {
+        id: "genericRequestPlugin",
+        init: function (app) { return init(app, options); },
+    };
+};
+exports.genericRequestPlugin = genericRequestPlugin;
+function init(app, options) {
+    var _this = this;
+    var expressApp = app.expressApp;
+    if (!expressApp) {
+        throw new Error("Express app not initialized");
+    }
+    expressApp[options.method](options.path, function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+        var authenticated;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!options.permissions) return [3 /*break*/, 2];
+                    if (!app.auth) {
+                        throw new Error("Route ".concat(options.method.toUpperCase(), " ").concat(options.path, " requires permissions but no auth plugin is configured"));
+                    }
+                    return [4 /*yield*/, app.auth.authenticateRequest(req, options.permissions)];
+                case 1:
+                    authenticated = _a.sent();
+                    if (!authenticated) {
+                        return [2 /*return*/, res.status(401).json({
+                                status: 401,
+                                error: {
+                                    title: "Unauthorized",
+                                    detail: "Authentication required or insufficient permissions",
+                                },
+                            })];
+                    }
+                    _a.label = 2;
+                case 2:
+                    // Call the handler
+                    options.handler(req, res, app);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    node_color_log_1.default.info("Registered genericRequest route ".concat(options.method, " ").concat(options.path));
+}

package/package.json

@@ -1,9 +1,9 @@
 {
     "name": "@flink-app/generic-request-plugin",
-    "version": "0.12.1-alpha.45",
+    "version": "0.12.1-alpha.47",
     "description": "Flink plugin that makes it possible to override default request handlers and handle specific requests manually",
     "scripts": {
-        "test": "echo \"Error: no test specified\"",
+        "test": "node --preserve-symlinks -r ts-node/register -- node_modules/jasmine/bin/jasmine --config=./spec/support/jasmine.json",
         "prepare": "tsc"
     },
     "author": "johan@frost.se",
@@ -18,11 +18,14 @@
         "node-color-log": "^5.3.1"
     },
     "devDependencies": {
-        "@flink-app/flink": "^0.12.1-alpha.45",
+        "@flink-app/flink": "^0.12.1-alpha.47",
         "@types/express": "4.17.11",
+        "@types/jasmine": "^3.7.1",
         "@types/node": "22.13.10",
+        "jasmine": "^3.7.0",
+        "jasmine-spec-reporter": "^7.0.0",
         "ts-node": "^9.1.1",
         "typescript": "5.4.5"
     },
-    "gitHead": "af426a157217c110ac9c7beb48e2e746968bec33"
+    "gitHead": "a98a0af7f11e4a97f68da4d0d67677df7d2a2749"
 }