diesel-core 1.6.8 → 1.7.0

package/dist/constant.js

@@ -0,0 +1,11 @@
+export const supportedMethods = [
+    "GET",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "ANY",
+    "HEAD",
+    "OPTIONS",
+    "PROPFIND",
+];

package/dist/ctx.d.ts

@@ -1,6 +1,6 @@
 import { Server } from "bun";
-import type { ContextType, CookieOptions } from "./types";
-export declare class Context implements ContextType {
+import type { CookieOptions } from "./types";
+export declare class Context {
     req: Request;
     server?: Server | undefined;
     path?: string | undefined;
@@ -25,10 +25,10 @@ export declare class Context implements ContextType {
     get query(): Record<string, string>;
     get params(): Record<string, string>;
     get body(): Promise<any>;
-    text(data: string, status?: number): Response;
-    send<T>(data: T, status?: number): Response;
-    json<T>(object: T, status?: number): Response;
-    file(filePath: string, mime_Type?: string, status?: number): Response;
+    text(data: string, status?: number, customHeaders?: HeadersInit): Response;
+    send<T>(data: T, status?: number, customHeaders?: HeadersInit): Response;
+    json<T>(object: T, status?: number, customHeaders?: HeadersInit): Response;
+    file(filePath: string, mimeType?: string, status?: number, customHeaders?: HeadersInit): Response;
     ejs(viewPath: string, data?: {}, status?: number): Promise<Response>;
     redirect(path: string, status?: number): Response;
     setCookie(name: string, value: string, options?: CookieOptions): this;

package/dist/ctx.js

@@ -0,0 +1,326 @@
+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());
+    });
+};
+import { getMimeType } from "./utils/mimeType";
+let ejsInstance = null;
+function getEjs() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!ejsInstance) {
+            const mod = yield import("ejs");
+            ejsInstance = mod.default || mod;
+        }
+        return ejsInstance;
+    });
+}
+const typeMap = {
+    string: "text/plain; charset=utf-8",
+    object: "application/json; charset=utf-8",
+    Uint8Array: "application/octet-stream",
+    ArrayBuffer: "application/octet-stream",
+};
+export class Context {
+    constructor(req, server, path, routePattern, paramNames, env, executionContext) {
+        this.headers = new Headers();
+        // Lazily initialized
+        this.parsedQuery = null;
+        this.parsedParams = null;
+        this.parsedCookies = null;
+        this.parsedBody = null;
+        this.contextData = {};
+        this.urlObject = null;
+        this.req = req;
+        this.server = server;
+        this.path = path;
+        this.routePattern = routePattern;
+        this.executionContext = executionContext;
+        this.env = env;
+        this.paramNames = paramNames;
+    }
+    // Methods
+    setHeader(key, value) {
+        this.headers.set(key, value);
+        return this;
+    }
+    removeHeader(key) {
+        this.headers.delete(key);
+        return this;
+    }
+    set(key, value) {
+        this.contextData[key] = value;
+        return this;
+    }
+    get(key) {
+        return this.contextData[key];
+    }
+    get ip() {
+        var _a, _b;
+        if (this.server)
+            return (_b = (_a = this.server.requestIP(this.req)) === null || _a === void 0 ? void 0 : _a.address) !== null && _b !== void 0 ? _b : null;
+        return this.req.headers.get("CF-Connecting-IP") || null;
+    }
+    get url() {
+        if (!this.urlObject) {
+            this.urlObject = new URL(this.req.url);
+        }
+        return this.urlObject;
+    }
+    get query() {
+        if (!this.parsedQuery) {
+            this.parsedQuery = this.url.search ? Object.fromEntries(this.url.searchParams) : {};
+        }
+        return this.parsedQuery;
+    }
+    get params() {
+        var _a;
+        if (!Array.isArray(this.paramNames)) {
+            return this.paramNames;
+        }
+        if (!this.parsedParams) {
+            try {
+                this.parsedParams = extractParam(this.paramNames, this.path);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new Error(`Failed to extract route parameters: ${message}`);
+            }
+        }
+        return (_a = this.parsedParams) !== null && _a !== void 0 ? _a : {};
+    }
+    get body() {
+        if (this.req.method === "GET") {
+            console.error(`you are trying to access body in GET method ${this.path}`);
+            return Promise.resolve({});
+        }
+        if (!this.parsedBody) {
+            this.parsedBody = (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const result = yield parseBody(this.req);
+                    if (result.error) {
+                        throw new Error(result.error);
+                    }
+                    return Object.keys(result).length === 0 ? null : result;
+                }
+                catch (error) {
+                    throw new Error("Invalid request body format");
+                    // const message = error instanceof Error ? error.message : String(error);
+                    // throw new Error(`Failed to parse request body: ${message}`);
+                }
+            }))();
+        }
+        return this.parsedBody;
+    }
+    text(data, status = 200, customHeaders) {
+        if (customHeaders) {
+            for (const [key, value] of Object.entries(customHeaders)) {
+                this.headers.set(key, value);
+            }
+        }
+        if (!this.headers.has("Content-Type")) {
+            this.headers.set("Content-Type", "text/plain; charset=utf-8");
+        }
+        return new Response(data, { status, headers: this.headers });
+    }
+    send(data, status = 200, customHeaders) {
+        var _a;
+        if (customHeaders) {
+            for (const [key, value] of Object.entries(customHeaders)) {
+                this.headers.set(key, value);
+            }
+        }
+        let dataType;
+        if (data instanceof Uint8Array)
+            dataType = "Uint8Array";
+        else if (data instanceof ArrayBuffer)
+            dataType = "ArrayBuffer";
+        else
+            dataType = typeof data;
+        if (!this.headers.has("Content-Type")) {
+            this.headers.set("Content-Type", (_a = typeMap[dataType]) !== null && _a !== void 0 ? _a : "text/plain; charset=utf-8");
+        }
+        const responseData = dataType === "object" && data !== null
+            ? JSON.stringify(data)
+            : data;
+        return new Response(responseData, { status, headers: this.headers });
+    }
+    json(object, status = 200, customHeaders) {
+        if (customHeaders) {
+            for (const [key, value] of Object.entries(customHeaders)) {
+                this.headers.set(key, value);
+            }
+        }
+        if (!this.headers.has("Content-Type")) {
+            this.headers.set("Content-Type", "application/json; charset=utf-8");
+        }
+        return new Response(JSON.stringify(object), { status, headers: this.headers });
+    }
+    file(filePath, mimeType, status = 200, customHeaders) {
+        if (customHeaders) {
+            for (const [key, value] of Object.entries(customHeaders)) {
+                this.headers.set(key, value);
+            }
+        }
+        if (!this.headers.has("Content-Type")) {
+            this.headers.set("Content-Type", mimeType !== null && mimeType !== void 0 ? mimeType : getMimeType(filePath));
+        }
+        const file = Bun.file(filePath);
+        return new Response(file, { status, headers: this.headers });
+    }
+    ejs(viewPath_1) {
+        return __awaiter(this, arguments, void 0, function* (viewPath, data = {}, status = 200) {
+            // this.status = status;
+            const ejs = yield getEjs();
+            try {
+                const template = yield Bun.file(viewPath).text();
+                const rendered = ejs.render(template, data);
+                const headers = new Headers({ "Content-Type": "text/html; charset=utf-8" });
+                return new Response(rendered, { status, headers });
+            }
+            catch (error) {
+                console.error("EJS Rendering Error:", error);
+                return new Response("Error rendering template", { status: 500 });
+            }
+        });
+    }
+    redirect(path, status = 302) {
+        this.headers.set("Location", path);
+        return new Response(null, { status, headers: this.headers });
+    }
+    setCookie(name, value, options = {}) {
+        let cookieString = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+        if (options.maxAge)
+            cookieString += `; Max-Age=${options.maxAge}`;
+        if (options.expires)
+            cookieString += `; Expires=${options.expires.toUTCString()}`;
+        if (options.path)
+            cookieString += `; Path=${options.path}`;
+        if (options.domain)
+            cookieString += `; Domain=${options.domain}`;
+        if (options.secure)
+            cookieString += `; Secure`;
+        if (options.httpOnly)
+            cookieString += `; HttpOnly`;
+        if (options.sameSite)
+            cookieString += `; SameSite=${options.sameSite}`;
+        this.headers.append("Set-Cookie", cookieString);
+        return this;
+    }
+    get cookies() {
+        if (!this.parsedCookies) {
+            const cookieHeader = this.req.headers.get("cookie");
+            this.parsedCookies = cookieHeader ? parseCookie(cookieHeader) : {};
+        }
+        return this.parsedCookies;
+    }
+    // Streams
+    stream(callback) {
+        const headers = new Headers(this.headers);
+        const stream = new ReadableStream({
+            start(controller) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    yield callback(controller);
+                    controller.close();
+                });
+            },
+        });
+        return new Response(stream, { headers });
+    }
+    yieldStream(callback) {
+        return new Response(
+        // {
+        //   async *[Symbol.asyncIterator]() {
+        //     yield* callback();
+        //   },
+        // },
+        // { headers: this.headers }
+        );
+    }
+}
+// function parseCookie(cookieHeader: string | undefined): Record<string, string> {
+//   const cookies: Record<string, string> = {};
+//   const cookiesArray = cookieHeader?.split(";")!;
+//   for (let i = 0; i < cookiesArray?.length!; i++) {
+//     const [cookieName, ...cookieValeParts] = cookiesArray[i].trim().split("=");
+//     const cookieVale = cookieValeParts?.join("=").trim();
+//     if (cookieName) {
+//       cookies[cookieName.trim()] = decodeURIComponent(cookieVale);
+//     }
+//   }
+//   return cookies;
+// }
+function parseCookie(cookieHeader) {
+    return Object.fromEntries(cookieHeader.split(";").map((cookie) => {
+        const [name, ...valueParts] = cookie.trim().split("=");
+        return [name, decodeURIComponent(valueParts.join("="))];
+    }));
+}
+export function extractParam(paramNames, incomingPath) {
+    // ["id","name"]
+    const param = {};
+    // inComingpath = /user/2/pradeep
+    const [pathWithoutQuery] = incomingPath.split("?");
+    const pathSegments = pathWithoutQuery.split("/").filter(s => s !== '');
+    // let segmentStart = 0
+    // let segmentIndex = 0
+    // const segments: string[] = []
+    // for (let i = 0; i <= pathWithoutQuery.length; i++) {
+    //   if (i === pathWithoutQuery.length || pathWithoutQuery.charCodeAt(i) === 47) { // '/'
+    //     if (i > segmentStart) {
+    //       segments[segmentIndex++] = pathWithoutQuery.slice(segmentStart, i)
+    //     }
+    //     segmentStart = i + 1
+    //   }
+    // }
+    const start = pathSegments.length - paramNames.length;
+    for (let i = 0; i < paramNames.length; i++) {
+        param[paramNames[i]] = pathSegments[start + i];
+    }
+    return param;
+}
+export function extractDynamicParams(originalPath, incomingPath) {
+    const params = {};
+    const routeSegments = originalPath.split("/");
+    const [pathWithoutQuery] = incomingPath.split("?");
+    const pathSegments = pathWithoutQuery.split("/");
+    if (routeSegments.length !== pathSegments.length)
+        return null;
+    for (let i = 0; i < routeSegments.length; i++) {
+        const segment = routeSegments[i];
+        if (segment.charCodeAt(0) === 58) {
+            params[segment.slice(1)] = pathSegments[i];
+        }
+    }
+    return params;
+}
+function parseBody(req) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const contentType = req.headers.get("Content-Type") || '';
+        if (!contentType)
+            return {};
+        const contentLength = req.headers.get("Content-Length");
+        if (contentLength === "0" || !req.body) {
+            return {};
+        }
+        if (contentType.startsWith("application/json")) {
+            return yield req.json();
+        }
+        if (contentType.startsWith("application/x-www-form-urlencoded")) {
+            const body = yield req.text();
+            return Object.fromEntries(new URLSearchParams(body));
+        }
+        if (contentType.startsWith("multipart/form-data")) {
+            const formData = yield req.formData();
+            const obj = {};
+            for (const [key, value] of formData.entries()) {
+                obj[key] = value;
+            }
+            return obj;
+        }
+        return { error: "Unknown request body type" };
+    });
+}

package/dist/handleRequest.d.ts

@@ -1,3 +1,3 @@
 import { Server } from "bun";
-import type { DieselT } from "./types";
-export default function handleRequest(req: Request, server: Server, diesel: DieselT, env?: Record<string, any>, executionContext?: any): Promise<Response | undefined>;
+import Diesel from "./main";
+export default function handleRequest(req: Request, server: Server, diesel: Diesel, env?: Record<string, any>, executionContext?: any): Promise<Response | undefined>;

package/dist/handleRequest.js

@@ -0,0 +1,83 @@
+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());
+    });
+};
+import { Context } from "./ctx";
+import { tryDecodeURI } from "./utils/urls";
+import { generateErrorResponse, handleRouteNotFound, runFilter, runHooks } from "./utils/request.util";
+import { isPromise } from "./utils/promise";
+export default function handleRequest(req, server, diesel, env, executionContext) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let pathname;
+        const start = req.url.indexOf('/', req.url.indexOf(':') + 4);
+        let i = start;
+        for (; i < req.url.length; i++) {
+            const charCode = req.url.charCodeAt(i);
+            if (charCode === 37) { // percent-encoded
+                const queryIndex = req.url.indexOf('?', i);
+                const path = req.url.slice(start, queryIndex === -1 ? undefined : queryIndex);
+                pathname = tryDecodeURI(path.includes('%25') ? path.replace(/%25/g, '%2525') : path);
+                break;
+            }
+            else if (charCode === 63) {
+                break;
+            }
+        }
+        if (!pathname) {
+            pathname = req.url.slice(start, i);
+        }
+        const matchedRouteHandler = diesel.router.find(req.method, pathname);
+        const ctx = new Context(req, server, pathname, matchedRouteHandler === null || matchedRouteHandler === void 0 ? void 0 : matchedRouteHandler.path, env, executionContext);
+        // const ctx = createCtx(req,server,pathname,routeHandler?.path)
+        // PipeLines such as filters , middlewares, hooks
+        // if (diesel.hasOnReqHook)
+        //   await runHooks('onRequest', diesel.hooks.onRequest, [req, pathname, server])
+        // middleware execution
+        // if (diesel.hasMiddleware) {
+        //   const mwResult = await runMiddlewares(diesel, pathname, ctx);
+        //   if (mwResult) return mwResult;
+        // }
+        // filter execution
+        if (diesel.hasFilterEnabled) {
+            const filterResponse = yield runFilter(diesel, pathname, ctx);
+            if (filterResponse)
+                return filterResponse;
+        }
+        // if route not found
+        // if (!routeHandler) return await handleRouteNotFound(diesel, ctx, pathname)
+        // pre-handler
+        if (diesel.hasPreHandlerHook) {
+            const result = yield runHooks('preHandler', diesel.hooks.preHandler, [ctx]);
+            if (result)
+                return result;
+        }
+        let finalResult;
+        const handlers = matchedRouteHandler === null || matchedRouteHandler === void 0 ? void 0 : matchedRouteHandler.handler;
+        if (handlers.length === 1) {
+            const result = handlers[0](ctx);
+            finalResult = isPromise(result) ? yield result : result;
+        }
+        else {
+            for (let i = 0; i < handlers.length; i++) {
+                const result = handlers[i](ctx);
+                finalResult = isPromise(result) ? yield result : result;
+                if (finalResult)
+                    break;
+            }
+        }
+        // onSend
+        if (diesel.hasOnSendHook) {
+            const response = yield runHooks('onSend', diesel.hooks.onSend, [ctx, finalResult]);
+            if (response)
+                return response;
+        }
+        return finalResult !== null && finalResult !== void 0 ? finalResult : yield handleRouteNotFound(diesel, ctx, pathname);
+        // if we dont return a response then by default Bun shows a err 
+        return generateErrorResponse(500, "No response returned from handler.");
+    });
+}

package/dist/http-exception.js

@@ -0,0 +1,20 @@
+export class HTTPException extends Error {
+    constructor(status = 500, options) {
+        super(options === null || options === void 0 ? void 0 : options.message, { cause: options === null || options === void 0 ? void 0 : options.cause });
+        this.name = 'HTTPException';
+        this.res = options === null || options === void 0 ? void 0 : options.res;
+        this.status = status;
+    }
+    getResponse() {
+        if (this.res) {
+            const newResponse = new Response(this.res.body, {
+                status: this.status,
+                headers: this.res.headers,
+            });
+            return newResponse;
+        }
+        return new Response(this.message, {
+            status: this.status,
+        });
+    }
+}

package/dist/http-exception.test.js

@@ -0,0 +1,50 @@
+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());
+    });
+};
+import { describe, expect, it } from 'bun:test';
+import { HTTPException } from './http-exception';
+describe('HTTPException', () => {
+    it('Should be 401 HTTP exception object', () => __awaiter(void 0, void 0, void 0, function* () {
+        // We should throw an exception if is not authorized
+        // because next handlers should not be fired.
+        const exception = new HTTPException(401, {
+            message: 'Unauthorized',
+        });
+        const res = exception.getResponse();
+        expect(res.status).toBe(401);
+        expect(yield res.text()).toBe('Unauthorized');
+        expect(exception.status).toBe(401);
+        expect(exception.message).toBe('Unauthorized');
+    }));
+    it('Should be accessible to the object causing the exception', () => __awaiter(void 0, void 0, void 0, function* () {
+        // We should pass the cause of the error to the cause option
+        // because it makes debugging easier.
+        const error = new Error('Server Error');
+        const exception = new HTTPException(500, {
+            message: 'Internal Server Error',
+            cause: error,
+        });
+        const res = exception.getResponse();
+        expect(res.status).toBe(500);
+        expect(yield res.text()).toBe('Internal Server Error');
+        expect(exception.status).toBe(500);
+        expect(exception.message).toBe('Internal Server Error');
+        expect(exception.cause).toBe(error);
+    }));
+    it('Should prioritize the status code over the code in the response', () => __awaiter(void 0, void 0, void 0, function* () {
+        const exception = new HTTPException(400, {
+            res: new Response('An exception', {
+                status: 200,
+            }),
+        });
+        const res = exception.getResponse();
+        expect(res.status).toBe(400);
+        expect(yield res.text()).toBe('An exception');
+    }));
+});

package/dist/main.d.ts

@@ -20,7 +20,7 @@ export default class Diesel {
     FilterRoutes: string[] | null | undefined;
     filters: Set<string>;
     filterFunction: Function[];
-    private hasFilterEnabled;
+    hasFilterEnabled: boolean;
     private serverInstance;
     staticFiles: any;
     user_jwt_secret: string;