viojs-middlewares 1.0.0

package/dist/cookie.d.ts

@@ -0,0 +1,16 @@
+import { BaseContext, Next } from 'viojs-core';
+export interface CookieOptions {
+    maxAge?: number;
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+}
+declare module 'viojs-core' {
+    interface BaseContext {
+        getCookie(name: string): string | undefined;
+        setCookie(name: string, value: string, options?: CookieOptions): void;
+    }
+}
+export declare const cookieMiddleware: () => (ctx: BaseContext, next: Next) => Promise<void>;

package/dist/cookie.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cookieMiddleware = void 0;
+const cookieMiddleware = () => {
+    return async (ctx, next) => {
+        let parsedCookies;
+        ctx.getCookie = (name) => {
+            if (!parsedCookies) {
+                parsedCookies = {};
+                const cookieHeader = ctx.headers['cookie'];
+                if (cookieHeader) {
+                    cookieHeader.split(';').forEach(c => {
+                        const [k, v] = c.split('=');
+                        if (k && v) {
+                            parsedCookies[k.trim()] = decodeURIComponent(v.trim());
+                        }
+                    });
+                }
+            }
+            return parsedCookies[name];
+        };
+        ctx.setCookie = (name, value, options = {}) => {
+            let cookieStr = `${name}=${encodeURIComponent(value)}`;
+            if (options.maxAge !== undefined)
+                cookieStr += `; Max-Age=${options.maxAge}`;
+            if (options.path)
+                cookieStr += `; Path=${options.path}`;
+            if (options.domain)
+                cookieStr += `; Domain=${options.domain}`;
+            if (options.secure)
+                cookieStr += `; Secure`;
+            if (options.httpOnly)
+                cookieStr += `; HttpOnly`;
+            if (options.sameSite)
+                cookieStr += `; SameSite=${options.sameSite}`;
+            if (!ctx.responseHeaders['Set-Cookie']) {
+                ctx.responseHeaders['Set-Cookie'] = [];
+            }
+            else if (typeof ctx.responseHeaders['Set-Cookie'] === 'string') {
+                ctx.responseHeaders['Set-Cookie'] = [ctx.responseHeaders['Set-Cookie']];
+            }
+            ctx.responseHeaders['Set-Cookie'].push(cookieStr);
+        };
+        await next();
+    };
+};
+exports.cookieMiddleware = cookieMiddleware;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { cookieMiddleware as cookie } from './cookie';
+export { staticMiddleware as staticFiles } from './static';

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.staticFiles = exports.cookie = void 0;
+var cookie_1 = require("./cookie");
+Object.defineProperty(exports, "cookie", { enumerable: true, get: function () { return cookie_1.cookieMiddleware; } });
+var static_1 = require("./static");
+Object.defineProperty(exports, "staticFiles", { enumerable: true, get: function () { return static_1.staticMiddleware; } });

package/dist/static.d.ts

@@ -0,0 +1,6 @@
+import { Middleware } from 'viojs-core';
+export interface StaticOptions {
+    index?: string;
+    maxAge?: number;
+}
+export declare const staticMiddleware: (rootPath: string, options?: StaticOptions) => Middleware;

package/dist/static.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.staticMiddleware = void 0;
+const path = __importStar(require("path"));
+const staticMiddleware = (rootPath, options = {}) => {
+    return async (ctx, next) => {
+        // Only serve static files on GET or HEAD
+        if (ctx.method !== 'GET' && ctx.method !== 'HEAD') {
+            return await next();
+        }
+        // Extremely simple static mapping
+        let reqPath = decodeURIComponent(ctx.url);
+        // Handle index file fallback for root
+        if (reqPath === '/' && options.index) {
+            reqPath = '/' + options.index;
+        }
+        // Prevent directory traversal attacks
+        const normalizedPath = path.normalize(reqPath).replace(/^(\.\.(\/|\\|$))+/, '');
+        const targetPath = path.join(rootPath, normalizedPath);
+        // Security check: ensure target path is still inside root path
+        if (!targetPath.startsWith(rootPath)) {
+            return await next();
+        }
+        try {
+            const stat = require('fs').statSync(targetPath);
+            if (stat.isFile()) {
+                // Expose a Cache-Control if user provided maxAge
+                if (options.maxAge !== undefined) {
+                    ctx.responseHeaders['Cache-Control'] = `public, max-age=${options.maxAge}`;
+                }
+                // Stream the file seamlessly
+                ctx.sendFile(targetPath);
+                // Do NOT call next(), as static file served effectively handles the request
+                return;
+            }
+        }
+        catch (e) {
+            // File not found or inaccessible, just pass to the next middleware (e.g. router)
+        }
+        await next();
+    };
+};
+exports.staticMiddleware = staticMiddleware;

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "viojs-middlewares",
+  "version": "1.0.0",
+  "description": "Official middlewares for @vio/core framework",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "viojs-core": "*"
+  }
+}