@wxn0brp/falcon-frame 0.9.1 → 0.9.3

package/dist/body.d.ts

@@ -4,5 +4,4 @@ export declare const urlencoded: ParseBodyFunction;
 export declare const yaml: ParseBodyFunction;
 export declare const toml: ParseBodyFunction;
 export declare const json5: ParseBodyFunction;
-export declare const xml: ParseBodyFunction;
 export declare const text: ParseBodyFunction;

package/dist/body.js

@@ -4,7 +4,6 @@ export const urlencoded = body => querystring.parse(body);
 export const yaml = body => Bun.YAML.parse(body);
 export const toml = body => Bun.TOML.parse(body);
 export const json5 = body => Bun.JSON5.parse(body);
-export const xml = body => new DOMParser().parseFromString(body, "text/xml");
 export const text = body => ({
     data: body,
 });

package/dist/debug.js

@@ -13,7 +13,8 @@ export function createDebug(opts = {}) {
         };
     const pass = process.env.FF_DEBUG_PASS;
     function isHostAllowed(req) {
-        return hosts.some(h => h === req.socket.remoteAddress);
+        const ip = req.ip || req.socket.remoteAddress || "";
+        return hosts.some(h => h === ip);
     }
     function checkAuth(req) {
         if (!pass)

package/dist/engine.d.ts

@@ -0,0 +1,19 @@
+import { FalconFrame } from "./index.js";
+export interface OfflineRequest {
+    method?: string;
+    url: string;
+    headers?: Record<string, string>;
+    body?: any;
+    cookies?: Record<string, string>;
+}
+export interface OfflineResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: any;
+}
+export declare class OfflineEngine {
+    private ff;
+    constructor(ff: FalconFrame<any>);
+    handle(request: OfflineRequest): Promise<OfflineResponse>;
+    private buildResponse;
+}

package/dist/engine.js

@@ -0,0 +1,146 @@
+import { getContentType } from "./body-utils.js";
+import { parseCookies } from "./helpers.js";
+import { extractParams, getMiddlewares, matchMiddleware } from "./middleware.js";
+import { validate } from "./valid.js";
+export class OfflineEngine {
+    ff;
+    constructor(ff) {
+        this.ff = ff;
+    }
+    async handle(request) {
+        const urlParts = request.url.split("?");
+        const path = decodeURIComponent(urlParts[0]);
+        const query = urlParts[1]
+            ? Object.fromEntries(new URLSearchParams(urlParts[1]))
+            : {};
+        request.method ??= "GET";
+        const cookies = request.cookies
+            ? {
+                ...request.cookies,
+                ...parseCookies(request.cookies.cookie || ""),
+            }
+            : parseCookies(request.headers?.cookie || "");
+        const res = {
+            statusCode: 200,
+            headers: {},
+            body: "",
+            _ended: false,
+            FF: this.ff,
+            json: (data) => {
+                res.headers["content-type"] = "application/json";
+                res.body = data;
+                res._ended = true;
+            },
+            send: (data) => {
+                res.body = data;
+                res._ended = true;
+            },
+            end: (data) => {
+                res.body = data;
+                res._ended = true;
+            },
+            status: (code) => {
+                res.statusCode = code;
+                return res;
+            },
+            setHeader: (name, value) => {
+                res.headers[name.toLowerCase()] = value;
+            },
+            ct: (type) => {
+                res.headers["content-type"] = type;
+                return res;
+            },
+            cookie: (name, value, opts = {}) => {
+                let c = `${name}=${encodeURIComponent(value)}`;
+                if (opts.maxAge !== undefined)
+                    c += `; Max-Age=${opts.maxAge}`;
+                if (opts.path)
+                    c += `; Path=${opts.path}`;
+                if (opts.httpOnly)
+                    c += `; HttpOnly`;
+                if (opts.secure)
+                    c += `; Secure`;
+                const existing = res.headers["set-cookie"];
+                res.headers["set-cookie"] = existing ? `${existing}, ${c}` : c;
+            },
+        };
+        const req = {
+            path,
+            query,
+            params: {},
+            body: {},
+            cookies,
+            headers: request.headers || {},
+            isBodyParsed: false,
+            FF: this.ff,
+            header: (name) => request.headers?.[name.toLowerCase()] || "",
+            valid: (schema, regexRules) => validate({
+                schema,
+                data: req.body,
+                regexRules,
+                isBodyParsed: req.isBodyParsed,
+            }),
+        };
+        if (request.body !== undefined && request.body !== null) {
+            const ct = getContentType(req) || "application/json";
+            const entry = this.ff.bodyParsers[ct];
+            if (entry) {
+                const raw = typeof request.body === "string"
+                    ? request.body
+                    : JSON.stringify(request.body);
+                try {
+                    req.body = (await entry.parse(raw, req, res)) ?? {};
+                    req.isBodyParsed = true;
+                }
+                catch {
+                    req.body = {};
+                }
+            }
+            else {
+                req.body = request.body;
+                req.isBodyParsed = true;
+            }
+        }
+        const middlewares = getMiddlewares(this.ff.middlewares, path + "/");
+        const matched = matchMiddleware(path, middlewares.filter(m => m.method === request.method.toLowerCase() || m.method === "all"));
+        if (matched.length === 0) {
+            res.statusCode = 404;
+            this.ff._404(req, res);
+            return this.buildResponse(res);
+        }
+        let i = 0;
+        const next = async () => {
+            if (i >= matched.length) {
+                res.statusCode = 404;
+                this.ff._404(req, res);
+                return;
+            }
+            const mw = matched[i++];
+            req.params = extractParams(mw.path, path);
+            try {
+                const result = await mw.middleware(req, res, next);
+                if (result && !res._ended) {
+                    typeof result === "string" ? res.send(result) : res.json(result);
+                }
+            }
+            catch (err) {
+                if (!res._ended) {
+                    res.statusCode = 500;
+                    this.ff._500(err, req, res);
+                }
+            }
+        };
+        await next();
+        return this.buildResponse(res);
+    }
+    buildResponse(res) {
+        const ct = res.headers["content-type"] || "";
+        return {
+            status: res.statusCode,
+            headers: res.headers,
+            body: ct.includes("application/json") && res.body
+                ? res.body
+                : (res.body ?? ""),
+        };
+    }
+}

package/dist/helpers.js

@@ -1,6 +1,6 @@
 import path from "path";
 export function parseCookies(cookieHeader) {
-    const cookies = {};
+    const cookies = Object.create(null);
     cookieHeader.split(";").forEach(cookie => {
         const [name, ...valueParts] = cookie.split("=");
         const value = decodeURIComponent(valueParts.join("=").trim());

package/dist/index.d.ts

@@ -43,6 +43,7 @@ export declare class FalconFrame<Vars extends Record<string, any> = {}> extends
     set500(handler: ErrorHandler): void;
 }
 export default FalconFrame;
+export { OfflineEngine, OfflineRequest, OfflineResponse } from "./engine.js";
 export * as Helpers from "./helpers.js";
 export type { FFOpts as Opts } from "./types.js";
 export { validateBody } from "./valid.js";

package/dist/index.js

@@ -68,10 +68,6 @@ export class FalconFrame extends Router {
                 fn: bodyParser.toml,
                 ct: "application/toml",
             },
-            xml: {
-                fn: bodyParser.xml,
-                ct: "application/xml",
-            },
             text: {
                 fn: bodyParser.text,
                 ct: "text/plain",
@@ -196,6 +192,7 @@ export class FalconFrame extends Router {
     }
 }
 export default FalconFrame;
+export { OfflineEngine } from "./engine.js";
 export * as Helpers from "./helpers.js";
 export { validateBody } from "./valid.js";
 export { FFResponse, renderHTML, Router };

package/dist/middleware.d.ts

@@ -1,3 +1,4 @@
 import { Middleware } from "./types.js";
 export declare function matchMiddleware(url: string, middlewares: Middleware[]): Middleware[];
 export declare function getMiddlewares(middlewares: Middleware[], matchUrl: string, basePath?: string): Middleware[];
+export declare function extractParams(routePath: string, requestPath: string): Record<string, string>;

package/dist/middleware.js

@@ -70,3 +70,16 @@ export function getMiddlewares(middlewares, matchUrl, basePath = "") {
     }
     return result;
 }
+export function extractParams(routePath, requestPath) {
+    const params = {};
+    if (!routePath.includes(":"))
+        return params;
+    const routeParts = routePath.split("/");
+    const pathParts = requestPath.split("/");
+    for (let i = 0; i < routeParts.length; i++) {
+        if (routeParts[i].startsWith(":")) {
+            params[routeParts[i].slice(1)] = pathParts[i];
+        }
+    }
+    return params;
+}

package/dist/req.js

@@ -2,7 +2,7 @@ import { randomUUID } from "crypto";
 import { URL } from "url";
 import { getContentType, getRawBody } from "./body-utils.js";
 import { getIP, parseCookies } from "./helpers.js";
-import { getMiddlewares, matchMiddleware } from "./middleware.js";
+import { extractParams, getMiddlewares, matchMiddleware } from "./middleware.js";
 import { FFResponse } from "./res.js";
 import { validate } from "./valid.js";
 export function handleRequest(req, res, FF, reRoute = false) {
@@ -77,17 +77,7 @@ export function handleRequest(req, res, FF, reRoute = false) {
         }
         const middleware = matchedMiddlewares[middlewareIndex++];
         logger.debug(`Executing middleware ${middlewareIndex} of ${matchedMiddlewares.length} matched for path [${middleware.path}]`);
-        if (middleware.path.includes(":")) {
-            const middlewareParts = middleware.path.split("/");
-            const reqPathParts = req.path.split("/");
-            req.params = {};
-            for (let i = 0; i < middlewareParts.length; i++) {
-                if (middlewareParts[i].startsWith(":")) {
-                    const paramName = middlewareParts[i].slice(1);
-                    req.params[paramName] = reqPathParts[i];
-                }
-            }
-        }
+        req.params = extractParams(middleware.path, req.path);
         req.middleware = middleware;
         try {
             const result = await middleware.middleware(req, res, next);

package/dist/static.js

@@ -38,11 +38,16 @@ export function handleStaticFiles(dirPath, opts) {
             res.setHeader("ETag", etag);
         }
         res.ct(getContentType(filePath, opts.utf8));
+        if (req.method === "HEAD") {
+            res.setHeader("Content-Length", stats.size);
+            res.end();
+            return true;
+        }
         fs.createReadStream(filePath).pipe(res);
         return true;
     };
     return (req, res, next) => {
-        if (req.method.toLowerCase() !== "get")
+        if (req.method !== "GET" && req.method !== "HEAD")
             return next();
         const apiPath = req.middleware.path;
         const unsafePath = req.path.replace(apiPath, "");

package/dist/types.d.ts

@@ -94,7 +94,6 @@ export interface FFOpts {
         json5?: boolean;
         yaml?: boolean;
         toml?: boolean;
-        xml?: boolean;
         text?: boolean;
     };
     xRequestId?: "auto" | "disable" | "manual";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/falcon-frame",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",
@@ -29,7 +29,7 @@
     "typescript": "^7"
   },
   "dependencies": {
-    "@wxn0brp/lucerna-log": "^0.2.4"
+    "@wxn0brp/lucerna-log": "^0.2.5"
   },
   "files": [
     "dist"