@wxn0brp/falcon-frame 0.6.3 → 0.7.1

package/dist/body-utils.d.ts

@@ -1,6 +1,6 @@
-import FalconFrame, { FFResponse } from "./index.js";
+import { FFResponse } from "./index.js";
 import type { FFRequest, ParseBodyFunction, RouteHandler, StandardBodyParserOptions } from "./types.js";
 export declare function parseLimit(limit: string | number): number;
 export declare function getContentType(req: FFRequest): string | undefined;
 export declare function getRawBody(req: FFRequest, res: FFResponse, limit: number): Promise<string>;
-export declare function getStandardBodyParser(type: string, parser: ParseBodyFunction, FF: FalconFrame, opts: StandardBodyParserOptions): RouteHandler;
+export declare function getStandardBodyParser(type: string, parser: ParseBodyFunction, opts: StandardBodyParserOptions): RouteHandler;

package/dist/body-utils.js

@@ -35,8 +35,6 @@ export function getRawBody(req, res, limit) {
                 res.status(413);
                 res.FF._413(req, res);
                 req.destroy();
-                // @ts-ignore
-                error.cancel = true;
                 return reject(error);
             }
         });
@@ -48,7 +46,7 @@ export function getRawBody(req, res, limit) {
         });
     });
 }
-export function getStandardBodyParser(type, parser, FF, opts) {
+export function getStandardBodyParser(type, parser, opts) {
     const limit = parseLimit(opts.limit || "100k");
     return async (req, res, next) => {
         if ((typeof req.body == "object" && Object.keys(req.body).length) || getContentType(req) !== type) {
@@ -56,11 +54,11 @@ export function getStandardBodyParser(type, parser, FF, opts) {
         }
         try {
             const body = await getRawBody(req, res, limit);
-            req.body = await parser(body, req, FF);
+            req.body = await parser(body, req, res);
             next();
         }
         catch (err) {
-            if (err.cancel)
+            if (res._ended)
                 return;
             req.body = {};
             next();

package/dist/body.d.ts

@@ -1,4 +1,3 @@
-import FalconFrame from "./index.js";
 import { RouteHandler, StandardBodyParserOptions } from "./types.js";
-export declare function json(FF: FalconFrame, opts?: StandardBodyParserOptions): RouteHandler;
-export declare function urlencoded(FF: FalconFrame, opts?: StandardBodyParserOptions): RouteHandler;
+export declare function json(opts?: StandardBodyParserOptions): RouteHandler;
+export declare function urlencoded(opts?: StandardBodyParserOptions): RouteHandler;

package/dist/body.js

@@ -1,8 +1,8 @@
 import querystring from "querystring";
 import { getStandardBodyParser } from "./body-utils.js";
-export function json(FF, opts = {}) {
-    return getStandardBodyParser("application/json", (body) => JSON.parse(body), FF, opts);
+export function json(opts = {}) {
+    return getStandardBodyParser("application/json", (body) => JSON.parse(body), opts);
 }
-export function urlencoded(FF, opts = {}) {
-    return getStandardBodyParser("application/x-www-form-urlencoded", (body) => querystring.parse(body), FF, opts);
+export function urlencoded(opts = {}) {
+    return getStandardBodyParser("application/x-www-form-urlencoded", (body) => querystring.parse(body), opts);
 }

package/dist/cors.d.ts

@@ -4,4 +4,4 @@ export interface Opts {
     accessControlAllowHeaders?: boolean;
     headers?: Record<string, string>;
 }
-export declare function createCORS(allowedOrigins: string[], opts?: Opts): RouteHandler;
+export declare function createCORS(allowedOrigins: (string | RegExp)[], opts?: Opts): RouteHandler;

package/dist/cors.js

@@ -4,6 +4,54 @@ function setHeader(res, opts) {
     if (opts.accessControlAllowHeaders)
         res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
 }
+function parseOrigin(origin) {
+    try {
+        const url = new URL(origin);
+        return {
+            host: url.hostname,
+            port: url.port ||
+                (url.protocol === "https:" ? "443" : "80")
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function matches(origin, pattern) {
+    if (pattern === "*")
+        return true;
+    if (pattern instanceof RegExp)
+        return pattern.test(origin);
+    if (pattern.toLowerCase() === origin.toLowerCase())
+        return true;
+    const o = parseOrigin(origin);
+    if (!o)
+        return false;
+    // *.example.com[:port]
+    if (pattern.startsWith("*.")) {
+        const [pHost, pPort] = pattern.split(":");
+        const base = pHost.slice(2).toLowerCase();
+        if (o.host !== base && o.host.endsWith("." + base)) {
+            return !pPort || pPort === "*" || pPort === o.port;
+        }
+        return false;
+    }
+    // localhost:port
+    if (pattern.includes(":")) {
+        const [pHost, pPort] = pattern.split(":");
+        const base = pHost.toLowerCase();
+        return o.host === base && (pPort === "*" || o.port === pPort);
+    }
+    return false;
+}
+function handleEnd(req, res, next, origin) {
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    if (req.method === "OPTIONS") {
+        res.statusCode = 204;
+        return res.end();
+    }
+    next();
+}
 export function createCORS(allowedOrigins, opts = {}) {
     opts = {
         accessControlAllowMethods: true,
@@ -16,24 +64,12 @@ export function createCORS(allowedOrigins, opts = {}) {
                 res.setHeader(key, value);
             }
         }
-        if (allowedOrigins.includes("*")) {
-            res.setHeader("Access-Control-Allow-Origin", "*");
-            setHeader(res, opts);
-            if (req.method === "OPTIONS") {
-                res.statusCode = 204;
-                return res.end();
-            }
-            return next();
-        }
+        setHeader(res, opts);
         const origin = req.headers.origin;
-        if (origin && allowedOrigins.includes(origin)) {
-            res.setHeader("Access-Control-Allow-Origin", origin);
-            setHeader(res, opts);
-            if (req.method === "OPTIONS") {
-                res.statusCode = 204;
-                return res.end();
-            }
-        }
+        if (allowedOrigins.includes("*"))
+            return handleEnd(req, res, next, origin || "*");
+        if (origin && allowedOrigins.some((pattern) => matches(origin, pattern)))
+            return handleEnd(req, res, next, origin);
         next();
     };
 }

package/dist/index.js

@@ -40,9 +40,9 @@ export class FalconFrame extends Router {
             ...opts,
         };
         if (!this.opts.disableJsonParser)
-            this.addBodyParser(json(this, { limit: this.opts.bodyLimit }));
+            this.addBodyParser(json({ limit: this.opts.bodyLimit }));
         if (!this.opts.disableUrlencodedParser)
-            this.addBodyParser(urlencoded(this, { limit: this.opts.bodyLimit }));
+            this.addBodyParser(urlencoded({ limit: this.opts.bodyLimit }));
         this.engine(".html", (path, options, callback, FF) => {
             try {
                 const content = renderHTML(path, options, [], FF);

package/dist/render.d.ts

@@ -2,4 +2,4 @@ import FalconFrame from "./index.js";
 export interface RenderOptions {
     noLayout?: boolean;
 }
-export declare function renderHTML(templatePath: string, data?: Record<string, any>, renderedPaths?: string[], FF?: FalconFrame, opts?: RenderOptions): string;
+export declare function renderHTML(templatePath: string, data?: Record<string, any>, renderedPaths?: string[], FF?: FalconFrame<any>, opts?: RenderOptions): string;

package/dist/req.d.ts

@@ -1,4 +1,4 @@
 import FalconFrame from "./index.js";
 import { FFResponse } from "./res.js";
 import { FFRequest } from "./types.js";
-export declare function handleRequest(req: FFRequest, res: FFResponse, FF: FalconFrame): void;
+export declare function handleRequest(req: FFRequest, res: FFResponse, FF: FalconFrame<any>): void;

package/dist/req.js

@@ -5,6 +5,7 @@ import { FFResponse } from "./res.js";
 import { validate } from "./valid.js";
 export function handleRequest(req, res, FF) {
     Object.setPrototypeOf(res, FFResponse.prototype);
+    req.FF = FF;
     res.FF = FF;
     const originalEnd = res.end;
     res.end = function (...any) {

package/dist/res.d.ts

@@ -3,7 +3,7 @@ import FalconFrame from "./index.js";
 import { CookieOptions, RenderOptions } from "./types.js";
 export declare class FFResponse extends http.ServerResponse {
     _ended: boolean;
-    FF: FalconFrame;
+    FF: FalconFrame<any>;
     /**
      * bind end for compatibility
      */

package/dist/types.d.ts

@@ -17,11 +17,12 @@ export interface Query {
 export interface Body {
     [key: string]: any;
 }
-export type ParseBodyFunction = (body: string, req: FFRequest, FF: FalconFrame) => Promise<Record<string, any>>;
+export type ParseBodyFunction = (body: string, req: FFRequest, res: FFResponse) => Promise<Record<string, any>>;
 export interface StandardBodyParserOptions {
     limit?: string | number;
 }
 export declare class FFRequest extends http.IncomingMessage {
+    FF: FalconFrame<any>;
     path: string;
     query: Query;
     params: Params;

package/dist/types.js

@@ -1,5 +1,6 @@
 import http from "http";
 export class FFRequest extends http.IncomingMessage {
+    FF;
     path;
     query;
     params;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/falcon-frame",
-  "version": "0.6.3",
+  "version": "0.7.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",
@@ -29,7 +29,7 @@
     "typescript": "*"
   },
   "dependencies": {
-    "@wxn0brp/lucerna-log": "^0.2.0"
+    "@wxn0brp/lucerna-log": "^0.2.2"
   },
   "files": [
     "dist"