@ozanarslan/corpus 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -13,6 +13,7 @@ export type ConfigEnvKey = OrString<keyof Env>;
 export type ConfigValueParser<T> = (value: string) => T;
 export declare class Config {
 	static get runtime(): string;
+	static get nodeEnv(): OrString<"development" | "production" | "test">;
 	static get env(): NodeJS.ProcessEnv;
 	static cwd(): string;
 	static resolvePath(...paths: string[]): string;
@@ -20,7 +21,7 @@ export declare class Config {
 		parser?: ConfigValueParser<T>;
 		fallback?: T;
 	}): T;
-	static set(key: string, value: string): void;
+	static set(key: string, value: string | number | boolean): void;
 }
 export type CookieOptions = {
 	name: string;
@@ -36,15 +37,13 @@ export type CookieOptions = {
 	partitioned?: boolean;
 	maxAge?: number;
 };
-export type CookiesInit = Cookies | [
-	string,
-	string
-][] | Record<string, string>;
+export type CookiesInit = CookiesAbstract | CookieOptions | CookieOptions[];
 declare abstract class CookiesAbstract {
 	abstract set(opts: CookieOptions): void;
 	abstract get(name: string): string | null;
 	abstract has(name: string): boolean;
-	abstract delete(opts: Pick<CookieOptions, "name" | "domain" | "path">): void;
+	abstract get count(): number;
+	abstract delete(name: string): void;
 	abstract entries(): IterableIterator<[
 		string,
 		string
@@ -52,18 +51,18 @@ declare abstract class CookiesAbstract {
 	abstract values(): Array<string>;
 	abstract keys(): Array<string>;
 	abstract toSetCookieHeaders(): Array<string>;
+	abstract setMany(optsArr: Array<CookieOptions>): void;
 	applyInit(init: CookiesInit): void;
-	decodeValue(cookieString: string): string | null;
-	createHeader(opts: CookieOptions): string;
 }
-/** Simple cookie map/jar to collect and manipulate cookies. */
 export declare class Cookies extends CookiesAbstract {
 	private instance;
 	constructor(init?: CookiesInit);
 	set(opts: CookieOptions): void;
+	setMany(optsArr: Array<CookieOptions>): void;
 	get(name: string): string | null;
 	has(name: string): boolean;
-	delete(opts: Pick<CookieOptions, "name" | "path" | "domain">): void;
+	get count(): number;
+	delete(name: string): void;
 	entries(): IterableIterator<[
 		string,
 		string
@@ -129,18 +128,24 @@ type HttpHeadersInit = Headers | HttpHeaders | [
 	string,
 	string
 ][] | (Record<string, string> & Partial<Record<HttpHeaderKey, string>>);
+/** Headers is extended to include helpers and intellisense for common header names. */
 declare class HttpHeaders extends Headers {
 	constructor(init?: HttpHeadersInit);
 	append(name: HttpHeaderKey, value: string): void;
 	set(name: HttpHeaderKey, value: string): void;
-	get(name: string): string | null;
-	has(name: string): boolean;
-	combine(source: HttpHeaders, target: HttpHeaders): HttpHeaders;
-	innerCombine(source: HttpHeaders): HttpHeaders;
-	setMany(init: HttpHeadersInit): void;
+	get(name: HttpHeaderKey): string | null;
+	has(name: HttpHeaderKey): boolean;
+	delete(name: HttpHeaderKey): void;
+	static combine(source: HttpHeaders, target: HttpHeaders): HttpHeaders;
+	innerCombine(source: HttpHeaders): void;
+	setMany(init: [
+		string,
+		string
+	][] | (Record<string, string> & Partial<Record<HttpHeaderKey, string>>)): void;
+	/** @deprecated */
 	static findHeaderInInit(init: HttpHeadersInit, name: HttpHeaderKey): string | null;
 }
-type HttpRequestInfo = Request | string | HttpRequest;
+type HttpRequestInfo = Request | string | HttpRequest | URL;
 /** Commonly used HTTP verbs. */
 export declare const Method: {
 	readonly GET: "GET";
@@ -160,14 +165,18 @@ type HttpRequestInit = Omit<RequestInit, "headers" | "method"> & {
 };
 /** HttpRequest includes a cookie jar, better headers, and some utilities. */
 declare class HttpRequest extends Request {
-	readonly input: HttpRequestInfo;
+	readonly info: HttpRequestInfo;
 	readonly init?: HttpRequestInit | undefined;
-	constructor(input: HttpRequestInfo, init?: HttpRequestInit | undefined);
-	get urlObject(): URL;
-	get headers(): HttpHeaders;
+	constructor(info: HttpRequestInfo, init?: HttpRequestInit | undefined);
+	readonly urlObject: URL;
+	readonly isPreflight: boolean;
+	readonly cookies: Cookies;
+	headers: HttpHeaders;
+	private resolveUrlObject;
+	private resolveHeaders;
 	/** Gets cookie header and collects cookies for the jar */
-	get cookies(): Cookies;
-	get isPreflight(): boolean;
+	private resolveCookies;
+	private resolveIsPreflight;
 }
 export type OrNumber<T> = T | (number & {});
 /** Commonly used HTTP status codes. */
@@ -605,7 +614,8 @@ declare class HttpError extends Error {
 	status: Status;
 	data?: unknown | undefined;
 	constructor(message: string, status: Status, data?: unknown | undefined);
-	static isStatusOf(err: unknown, status: Status): boolean;
+	toResponse(): HttpResponse;
+	isStatusOf(status: Status): boolean;
 	static internalServerError(msg?: string): HttpError;
 	static badRequest(msg?: string): HttpError;
 	static notFound(msg?: string): HttpError;
@@ -650,12 +660,13 @@ export declare class Parser {
 	static getSearch<S = UnknownObject>(url: URL, validate?: SchemaValidator<S>): Promise<S>;
 	static getBody<B = UnknownObject>(r: HttpRequest | HttpResponse | Response, validate?: SchemaValidator<B>): Promise<B>;
 	static getParams<P = UnknownObject>(endpoint: string, url: URL, validate?: SchemaValidator<P>): Promise<P>;
+	private static getUnknownBody;
 	private static getJsonBody;
 	private static getFormUrlEncodedBody;
 	private static getFormDataBody;
 	private static getTextBody;
 	static getNormalizedContentType(input: Request | Response): string;
-	private static processString;
+	static processString(value: string): string | boolean | number;
 }
 /** Abstract class for repository implementations */
 declare abstract class RepositoryAbstract {
@@ -701,29 +712,67 @@ declare class Cors {
 }
 export type ErrorHandler<R = unknown> = (err: Error) => MaybePromise<HttpResponse<R>>;
 export type RequestHandler<R = unknown> = (req: HttpRequest) => MaybePromise<HttpResponse<R>>;
-declare abstract class ServerAbstract {
+export type AfterResponseHandler = ((res: HttpResponse) => MaybePromise<HttpResponse>) | undefined;
+export interface ServerInterface {
+	serve(options: ServeOptions): void;
+	close(): Promise<void>;
+	setGlobalPrefix(value: string): void;
+	setCors(cors: CorsOptions): void;
+	/**
+	 *
+	 * Default error handler response will have a status of C.Error or 500 and json:
+	 *
+	 * ```typescript
+	 * { error: unknown | true, message: string }
+	 * ```
+	 *
+	 * If throw something other than an Error instance, you should probably handle it.
+	 * However the default response will have a status of 500 and json:
+	 *
+	 * ```typescript
+	 * { error: Instance, message: "Unknown" }
+	 * ```
+	 */
+	setOnError(handler: ErrorHandler): void;
+	/**
+	 *
+	 * Default not found handler response will have a status of 404 and json:
+	 *
+	 * ```typescript
+	 * { error: true, message: `${req.method} on ${req.url} does not exist.` }
+	 * ```
+	 */
+	setOnNotFound(handler: RequestHandler): void;
+	setOnBeforeListen(handler: () => MaybePromise<void>): void;
+	setOnBeforeClose(handler: () => MaybePromise<void>): void;
+	setOnAfterResponse(handler: AfterResponseHandler): void;
+	listen(port: ServeOptions["port"], hostname: ServeOptions["hostname"]): Promise<void>;
+	handle(request: Request): Promise<Response>;
+}
+declare abstract class ServerAbstract implements ServerInterface {
 	abstract serve(options: ServeOptions): void;
-	abstract exit(): Promise<void>;
+	abstract close(): Promise<void>;
 	protected cors: Cors | undefined;
-	protected handleBeforeListen: (() => MaybePromise<void>) | undefined;
-	protected handleBeforeExit: (() => MaybePromise<void>) | undefined;
-	protected handleAfterResponse: ((res: HttpResponse) => MaybePromise<HttpResponse>) | undefined;
+	get routes(): Array<[
+		string,
+		string
+	]>;
 	setGlobalPrefix(value: string): void;
 	setCors(cors: CorsOptions): void;
 	setOnError(handler: ErrorHandler): void;
 	setOnNotFound(handler: RequestHandler): void;
 	setOnBeforeListen(handler: () => MaybePromise<void>): void;
-	setOnBeforeExit(handler: () => MaybePromise<void>): void;
-	setOnAfterResponse(handler: (res: HttpResponse) => MaybePromise<HttpResponse>): void;
+	setOnBeforeClose(handler: () => MaybePromise<void>): void;
+	setOnAfterResponse(handler: AfterResponseHandler): void;
 	listen(port: ServeOptions["port"], hostname?: ServeOptions["hostname"]): Promise<void>;
 	handle(request: Request): Promise<Response>;
-	private prepare;
-	private handleError;
-	private handleNotFound;
-	private handleMethodNotAllowed;
-	private handlePreflight;
-	private handleRoute;
 	private getResponse;
+	protected handleBeforeListen: (() => MaybePromise<void>) | undefined;
+	protected handleBeforeClose: (() => MaybePromise<void>) | undefined;
+	protected handleAfterResponse: AfterResponseHandler;
+	protected handleError: ErrorHandler;
+	protected handleNotFound: RequestHandler;
+	protected handleMethodNotAllowed: RequestHandler;
 }
 /**
  * Server is the entrypoint to the app. It must be initialized before registering routes and middlewares.
@@ -733,23 +782,12 @@ export declare class Server extends ServerAbstract {
 	private instance;
 	constructor();
 	serve(options: ServeOptions): void;
-	exit(): Promise<void>;
+	close(): Promise<void>;
 }
-export type MiddlewareRegistryData = {
-	handler: MiddlewareHandler;
-	order: number;
-	routeId: RouteId | "*";
-};
 declare class MiddlewareRegistry {
-	readonly compiledCache: Map<`[${string}:${string}]`, MiddlewareHandler>;
-	readonly handlerMap: Map<number, MiddlewareHandler>;
-	readonly data: Array<MiddlewareRegistryData>;
-	readonly compiledMap: Map<string, MiddlewareHandler>;
+	private readonly map;
 	add(item: Middleware): void;
 	find(routeId: RouteId): MiddlewareHandler;
-	private internMiddlewareHandler;
-	private push;
-	private findInsertIndex;
 	private compile;
 }
 export type AnyRouteModel = RouteModel<any, any, any, any>;
@@ -763,7 +801,10 @@ declare class ModelRegistry {
 export type RouteRegistryData = Pick<AnyRoute, "id" | "endpoint" | "method" | "pattern" | "handler">;
 declare class RouteRegistry {
 	private store;
-	list(): string;
+	list(): Array<[
+		string,
+		string
+	]>;
 	add(r: AnyRoute): void;
 	find(req: HttpRequest): RouteRegistryData;
 	private checkPossibleCollision;
@@ -778,7 +819,10 @@ declare class Router {
 	setGlobalPrefix(value: string): void;
 	routeRegistryInstance: RouteRegistry | undefined;
 	get routeRegistry(): RouteRegistry;
-	getRouteList(): string;
+	getRouteList(): Array<[
+		string,
+		string
+	]>;
 	addRoute(r: AnyRoute): void;
 	addController(c: ControllerAbstract): void;
 	findRoute(req: HttpRequest): RouteRegistryData;

package/dist/index.js

@@ -4,25 +4,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __require = import.meta.require;
@@ -168778,6 +168796,11 @@ var RuntimeOptions = {
   node: "node"
 };
 
+// src/utils/strIsDefined.ts
+function strIsDefined(input) {
+  return !!input?.trim() && typeof input === "string";
+}
+
 // src/Config/Config.ts
 import path from "path";
 
@@ -168789,8 +168812,12 @@ class Config {
     if (typeof process !== "undefined" && process?.env) {
       return RuntimeOptions.node;
     }
+    console.warn("\u26A0\uFE0F Runtime isn't Bun or NodeJS. Features may not be available. App might not start.");
     return "unknown";
   }
+  static get nodeEnv() {
+    return this.env.NODE_ENV ?? "development";
+  }
   static get env() {
     switch (this.runtime) {
       case RuntimeOptions.bun:
@@ -168798,6 +168825,7 @@ class Config {
       case RuntimeOptions.node:
         return process.env;
       default:
+        console.warn("\u26A0\uFE0F process.env wasn't available. Your environment variables are in memory.");
         return {};
     }
   }
@@ -168809,7 +168837,7 @@ class Config {
   }
   static get(key, opts) {
     const value = this.env[key];
-    if (value !== undefined && value !== "") {
+    if (strIsDefined(value)) {
       return opts?.parser ? opts?.parser(value) : value;
     }
     if (opts?.fallback !== undefined) {
@@ -168819,6 +168847,14 @@ class Config {
     return;
   }
   static set(key, value) {
+    if (typeof value === "number") {
+      this.env[key] = value.toString();
+      return;
+    }
+    if (typeof value === "boolean") {
+      this.env[key] = value ? "true" : "false";
+      return;
+    }
     this.env[key] = value;
   }
 }
@@ -168934,87 +168970,32 @@ var CommonHeaders = {
   Cookie: "Cookie"
 };
 
-// src/utils/strAfterMark.ts
-function strAfterMark(mark, input) {
-  const index = input.indexOf(mark);
-  return index === -1 ? "" : input.slice(index + mark.length);
-}
-
-// src/utils/strCapitalize.ts
-function strCapitalize(input) {
-  return input.length > 0 ? input.split(" ").map((part) => part.charAt(0).toLocaleUpperCase() + input.slice(1)).join(" ") : input;
-}
-
-// src/utils/strIsDefined.ts
-function strIsDefined(input) {
-  return !!input?.trim() && typeof input === "string";
-}
-
 // src/Cookies/CookiesAbstract.ts
 class CookiesAbstract {
   applyInit(init) {
     if (init instanceof CookiesAbstract) {
-      for (const [name, value] of init.entries()) {
+      for (const name of init.keys()) {
+        const value = init.get(name) ?? "";
         this.set({ name, value });
       }
     } else if (Array.isArray(init)) {
-      for (const [name, value] of init) {
-        if (!name || !value)
-          continue;
-        this.set({ name, value });
+      for (const opts of init) {
+        this.set(opts);
       }
     } else {
-      for (const [name, value] of Object.entries(init)) {
-        this.set({ name, value });
-      }
+      this.set(init);
     }
   }
-  decodeValue(cookieString) {
-    const encodedValue = strAfterMark("=", cookieString);
-    if (!encodedValue)
-      return null;
-    return decodeURIComponent(encodedValue);
-  }
-  createHeader(opts) {
-    let result = `${encodeURIComponent(opts.name)}=${encodeURIComponent(opts.value)}`;
-    if (strIsDefined(opts.domain)) {
-      result += `; Domain=${opts.domain}`;
-    }
-    if (strIsDefined(opts.path)) {
-      result += `; Path=${opts.path}`;
-    } else {
-      result += `; Path=/`;
-    }
-    if (opts.expires) {
-      if (typeof opts.expires === "number") {
-        result += `; Expires=${new Date(opts.expires).toUTCString()}`;
-      } else {
-        result += `; Expires=${opts.expires.toUTCString()}`;
-      }
-    }
-    if (opts.maxAge && Number.isInteger(opts.maxAge)) {
-      result += `; Max-Age=${opts.maxAge}`;
-    }
-    if (opts.secure === true) {
-      result += "; Secure";
-    }
-    if (opts.httpOnly === true) {
-      result += "; HttpOnly";
-    }
-    if (opts.partitioned === true) {
-      result += "; Partitioned";
-    }
-    if (strIsDefined(opts.sameSite)) {
-      result += `; SameSite=${strCapitalize(opts.sameSite)}`;
-    } else {
-      result += `; SameSite=Lax`;
-    }
-    return result;
-  }
 }
 
 // src/Cookies/CookiesUsingBun.ts
 class CookiesUsingBun extends CookiesAbstract {
+  constructor(init) {
+    super();
+    if (init) {
+      this.applyInit(init);
+    }
+  }
   map = new Bun.CookieMap;
   toSetCookieHeaders() {
     return this.map.toSetCookieHeaders();
@@ -169022,14 +169003,22 @@ class CookiesUsingBun extends CookiesAbstract {
   set(opts) {
     this.map.set(opts.name, opts.value, opts);
   }
+  setMany(optsArr) {
+    for (const opts of optsArr) {
+      this.set(opts);
+    }
+  }
   get(name) {
     return this.map.get(name);
   }
   has(name) {
     return this.map.has(name);
   }
-  delete(opts) {
-    this.map.delete(opts);
+  get count() {
+    return this.values().length;
+  }
+  delete(name) {
+    this.map.delete(name);
   }
   entries() {
     return this.map.entries();
@@ -169044,24 +169033,28 @@ class CookiesUsingBun extends CookiesAbstract {
 
 // src/Cookies/Cookies.ts
 class Cookies extends CookiesAbstract {
-  instance = new CookiesUsingBun;
+  instance;
   constructor(init) {
     super();
-    if (init) {
-      this.applyInit(init);
-    }
+    this.instance = new CookiesUsingBun(init);
   }
   set(opts) {
     return this.instance.set(opts);
   }
+  setMany(optsArr) {
+    return this.instance.setMany(optsArr);
+  }
   get(name) {
     return this.instance.get(name);
   }
   has(name) {
     return this.instance.has(name);
   }
-  delete(opts) {
-    return this.instance.delete(opts);
+  get count() {
+    return this.instance.count;
+  }
+  delete(name) {
+    return this.instance.delete(name);
   }
   entries() {
     return this.instance.entries();
@@ -169094,7 +169087,10 @@ class HttpHeaders extends Headers {
   has(name) {
     return super.has(name) || super.has(name.toLowerCase());
   }
-  combine(source, target) {
+  delete(name) {
+    return super.delete(name);
+  }
+  static combine(source, target) {
     source.forEach((value, key) => {
       if (key.toLowerCase() === "set-cookie") {
         target.append(key, value);
@@ -169105,10 +169101,11 @@ class HttpHeaders extends Headers {
     return target;
   }
   innerCombine(source) {
-    return this.combine(source, this);
+    HttpHeaders.combine(source, this);
   }
   setMany(init) {
-    for (const [key, value] of Object.entries(init)) {
+    const entries = Array.isArray(init) ? init : Object.entries(init);
+    for (const [key, value] of entries) {
       if (!strIsDefined(value))
         continue;
       this.set(key, value);
@@ -169206,7 +169203,7 @@ class HttpResponse {
     const res = new HttpResponse(undefined, {
       ...init,
       status: init?.status ?? Status.FOUND,
-      statusText: init?.statusText
+      statusText: init?.statusText ?? DefaultStatusTexts[Status.FOUND]
     });
     const urlString = url instanceof URL ? url.toString() : url;
     res.headers.set(CommonHeaders.Location, urlString);
@@ -169250,11 +169247,11 @@ class HttpError extends Error {
     this.status = status;
     this.data = data;
   }
-  static isStatusOf(err, status) {
-    if (err instanceof HttpError) {
-      return err.status === status;
-    }
-    return Status.INTERNAL_SERVER_ERROR === status;
+  toResponse() {
+    return new HttpResponse(this.data ? { error: this.data, message: this.message } : { error: true, message: this.message }, { status: this.status });
+  }
+  isStatusOf(status) {
+    return this.status === status;
   }
   static internalServerError(msg) {
     const status = Status.INTERNAL_SERVER_ERROR;
@@ -169347,13 +169344,15 @@ class Parser {
         case "text":
           data = await this.getTextBody(input);
           break;
+        case "unknown":
+          data = await this.getUnknownBody(input);
+          break;
         case "xml":
         case "binary":
         case "pdf":
         case "image":
         case "audio":
         case "video":
-        case "unknown":
           throw new HttpError("unprocessable.contentType", Status.UNPROCESSABLE_ENTITY);
         case "no-body-allowed":
         default:
@@ -169383,11 +169382,21 @@ class Parser {
     }
     return await this.parse(data, validate);
   }
+  static async getUnknownBody(input, validate) {
+    if (!validate) {
+      return await this.getTextBody(input);
+    }
+    try {
+      return await this.getJsonBody(input);
+    } catch {
+      return await this.getTextBody(input);
+    }
+  }
   static async getJsonBody(req) {
     return await req.json();
   }
-  static async getFormUrlEncodedBody(req) {
-    const text = await req.text();
+  static async getFormUrlEncodedBody(input) {
+    const text = await input.text();
     if (!text || text.trim().length === 0) {
       throw new SyntaxError("Body is empty");
     }
@@ -169398,8 +169407,8 @@ class Parser {
     }
     return body;
   }
-  static async getFormDataBody(req) {
-    const formData = await req.formData();
+  static async getFormDataBody(input) {
+    const formData = await input.formData();
     const entries = formData.entries();
     const body = {};
     for (const [key, value] of entries) {
@@ -169411,15 +169420,15 @@ class Parser {
     }
     return body;
   }
-  static async getTextBody(req) {
-    const contentLength = req.headers.get("content-length");
+  static async getTextBody(input) {
+    const contentLength = input.headers.get(CommonHeaders.ContentLength);
     const length = contentLength ? parseInt(contentLength) : 0;
     if (length > 0 && length < 1024 * 1024) {
-      const text2 = await req.text();
+      const text2 = await input.text();
       return this.processString(text2);
     }
-    const buffer = await req.arrayBuffer();
-    const contentType = req.headers.get("content-type") || "";
+    const buffer = await input.arrayBuffer();
+    const contentType = input.headers.get(CommonHeaders.ContentType) || "";
     const match = contentType.match(/charset=([^;]+)/i);
     const charset = match?.[1] ? match[1].trim() : null;
     const decoder = new TextDecoder(charset || "utf-8");
@@ -169463,6 +169472,8 @@ class Parser {
   }
   static processString(value) {
     let processedValue = value;
+    if (!strIsDefined(value))
+      return "";
     if (/^-?\d+(\.\d+)?$/.test(value)) {
       processedValue = Number(value);
     } else if (value.toLowerCase() === "true" || value.toLowerCase() === "false") {
@@ -169704,6 +169715,7 @@ class StaticRoute extends RouteAbstract {
     htm: "text/html",
     css: "text/css",
     js: "application/javascript",
+    ts: "application/javascript",
     mjs: "application/javascript",
     json: "application/json",
     png: "image/png",
@@ -169793,33 +169805,77 @@ class RepositoryAbstract {
     this.db = db;
   }
 }
+// src/utils/assert.ts
+function assert(condition, message) {
+  const conditionName = String(condition);
+  if (!condition) {
+    if (!message) {
+      message = `Assertion failed for ${conditionName}`;
+    } else {
+      message = `${conditionName}: ${message}`;
+    }
+    throw new Error(message);
+  }
+}
+
 // src/utils/strSplit.ts
-function strSplit(mark, input) {
-  return input.split(mark).map((part) => part.trim()).filter(Boolean);
+function strSplit(mark, input, minLength) {
+  const parts = input.split(mark).map((part) => part.trim()).filter(Boolean);
+  if (minLength) {
+    assert(parts.length >= minLength);
+    return parts;
+  }
+  return parts;
 }
 
 // src/Request/HttpRequest.ts
 class HttpRequest extends Request {
-  input;
+  info;
   init;
-  constructor(input, init) {
-    super(input, init);
-    this.input = input;
+  constructor(info, init) {
+    super(info, init);
+    this.info = info;
     this.init = init;
+    this.urlObject = this.resolveUrlObject();
+    this.headers = this.resolveHeaders();
+    this.cookies = this.resolveCookies();
+    this.isPreflight = this.resolveIsPreflight();
   }
-  get urlObject() {
-    return new URL(this.url);
+  urlObject;
+  isPreflight;
+  cookies;
+  headers;
+  resolveUrlObject() {
+    let urlObject;
+    switch (true) {
+      case this.info instanceof URL:
+        urlObject = this.info;
+        break;
+      case this.info instanceof HttpRequest:
+        urlObject = this.info.urlObject;
+        break;
+      case this.info instanceof Request:
+        urlObject = new URL(this.info.url);
+        break;
+      default:
+        urlObject = new URL(this.info);
+        break;
+    }
+    if (!urlObject.pathname) {
+      urlObject.pathname += "/";
+    }
+    return urlObject;
   }
-  get headers() {
-    if (this.input instanceof Request) {
-      return new HttpHeaders(this.input.headers);
-    } else if (this.init?.headers !== undefined) {
+  resolveHeaders() {
+    if (this.init?.headers !== undefined) {
       return new HttpHeaders(this.init.headers);
-    } else {
-      return new HttpHeaders;
     }
+    if (this.info instanceof Request || this.info instanceof HttpRequest) {
+      return new HttpHeaders(this.info.headers);
+    }
+    return new HttpHeaders;
   }
-  get cookies() {
+  resolveCookies() {
     const jar = new Cookies;
     const cookieHeader = this.headers.get(CommonHeaders.Cookie);
     if (cookieHeader) {
@@ -169833,93 +169889,52 @@ class HttpRequest extends Request {
     }
     return jar;
   }
-  get isPreflight() {
+  resolveIsPreflight() {
     const accessControlRequestMethodHeader = this.headers.has(CommonHeaders.AccessControlRequestMethod);
     return this.method === Method.OPTIONS && accessControlRequestMethodHeader;
   }
 }
 // src/Middleware/MiddlewareRegistry.ts
 class MiddlewareRegistry {
-  compiledCache = new Map;
-  handlerMap = new Map;
-  data = [];
-  compiledMap = new Map;
+  map = new Map;
   add(item) {
-    const order = this.data.length + 1;
     const useOn = item.useOn;
     if (useOn === "*") {
       const arr = [];
-      const globals = this.compiledMap.get("*");
+      const globals = this.map.get("*");
       if (globals) {
         arr.push(globals);
       }
       arr.push(item.handler);
-      this.compiledMap.set("*", this.compile(arr));
+      this.map.set("*", this.compile(arr));
       return;
     }
     const targets = Array.isArray(useOn) ? useOn : [useOn];
     for (const target of targets) {
       const routeIds = target instanceof Route ? [target.id] : target instanceof ControllerAbstract ? Array.from(target.routeIds) : [];
       for (const routeId of routeIds) {
-        console.log("adding mw to", routeId);
         const arr = [];
-        const locals = this.compiledMap.get(routeId);
+        const locals = this.map.get(routeId);
         if (locals) {
           arr.push(locals);
         }
         arr.push(item.handler);
-        this.compiledMap.set(routeId, this.compile(arr));
+        this.map.set(routeId, this.compile(arr));
       }
     }
   }
   find(routeId) {
     const arr = [];
-    const globals = this.compiledMap.get("*");
+    const globals = this.map.get("*");
     if (globals) {
       arr.push(globals);
     }
-    const locals = this.compiledMap.get(routeId);
+    const locals = this.map.get(routeId);
     if (locals) {
       arr.push(locals);
     }
-    console.log(routeId, arr);
     return this.compile(arr);
   }
-  internMiddlewareHandler(order, fn) {
-    const existing = this.handlerMap.get(order);
-    if (existing)
-      return existing;
-    this.handlerMap.set(order, fn);
-    return fn;
-  }
-  push(data) {
-    if (data.routeId === "*") {
-      this.compiledCache.clear();
-    } else {
-      this.compiledCache.delete(data.routeId);
-    }
-    const insertIndex = this.findInsertIndex(data.order);
-    this.data.splice(insertIndex, 0, {
-      order: data.order,
-      routeId: data.routeId,
-      handler: this.internMiddlewareHandler(data.order, data.handler)
-    });
-    console.log(this.data);
-    console.log(this.compiledCache);
-  }
-  findInsertIndex(order) {
-    let left = 0;
-    let right = this.data.length;
-    while (left < right) {
-      const mid = left + right >> 1;
-      if (this.data[mid].order < order) {
-        left = mid + 1;
-      } else {
-        right = mid;
-      }
-    }
-    return left;
-  }
   compile(handlers) {
     return async (ctx) => {
       for (const h of handlers) {
@@ -169987,8 +170002,7 @@ function strIsEqual(source, target, modifier) {
 class RouteRegistry {
   store = new Map;
   list() {
-    return Array.from(this.store.values()).map((r) => `${r.method}	:	${r.endpoint}`).join(`
-`);
+    return Array.from(this.store.values()).map((r) => [r.method, r.endpoint]);
   }
   add(r) {
     this.checkPossibleCollision(r);
@@ -170204,9 +170218,9 @@ class Cors {
 // src/Server/ServerAbstract.ts
 class ServerAbstract {
   cors;
-  handleBeforeListen;
-  handleBeforeExit;
-  handleAfterResponse;
+  get routes() {
+    return getRouterInstance().getRouteList();
+  }
   setGlobalPrefix(value) {
     Config.set(_globalPrefixEnvKey, value);
   }
@@ -170222,15 +170236,17 @@ class ServerAbstract {
   setOnBeforeListen(handler) {
     this.handleBeforeListen = handler;
   }
-  setOnBeforeExit(handler) {
-    this.handleBeforeExit = handler;
+  setOnBeforeClose(handler) {
+    this.handleBeforeClose = handler;
   }
   setOnAfterResponse(handler) {
     this.handleAfterResponse = handler;
   }
   async listen(port, hostname = "0.0.0.0") {
     try {
-      await this.prepare(port, hostname);
+      process.on("SIGINT", () => this.close());
+      process.on("SIGTERM", () => this.close());
+      console.log(`Listening on ${hostname}:${port}`);
       await this.handleBeforeListen?.();
       this.serve({
         port,
@@ -170239,7 +170255,7 @@ class ServerAbstract {
       });
     } catch (err) {
       console.error("Server unable to start:", err);
-      await this.exit();
+      await this.close();
     }
   }
   async handle(request) {
@@ -170253,51 +170269,43 @@ class ServerAbstract {
     }
     return res.response;
   }
-  async prepare(port, hostname) {
-    process.on("SIGINT", () => this.exit());
-    process.on("SIGTERM", () => this.exit());
-    const routes = getRouterInstance().getRouteList();
-    console.log(`Listening on ${hostname}:${port}
-${routes}`);
+  async getResponse(req) {
+    try {
+      if (req.isPreflight) {
+        return new HttpResponse("Departed");
+      }
+      const handler = getRouterInstance().getRouteHandler(req);
+      return await handler();
+    } catch (err) {
+      if (err instanceof HttpError) {
+        if (err.isStatusOf(Status.NOT_FOUND)) {
+          return await this.handleNotFound(req);
+        }
+        if (err.isStatusOf(Status.METHOD_NOT_ALLOWED)) {
+          return await this.handleMethodNotAllowed(req);
+        }
+      }
+      return await this.handleError(err);
+    }
   }
+  handleBeforeListen;
+  handleBeforeClose;
+  handleAfterResponse;
   handleError = async (err) => {
-    let body = err;
-    let status = Status.INTERNAL_SERVER_ERROR;
+    if (!(err instanceof Error)) {
+      return new HttpResponse({ error: err, message: "Unknown" }, { status: Status.INTERNAL_SERVER_ERROR });
+    }
     if (err instanceof HttpError) {
-      body = err.data ?? err.message;
-      status = err.status;
+      return err.toResponse();
     }
-    return new HttpResponse({ error: body }, { status });
+    return new HttpResponse({ error: err, message: err.message }, { status: Status.INTERNAL_SERVER_ERROR });
   };
   handleNotFound = async (req) => {
-    return new HttpResponse({ error: `${req.method} on ${req.url} does not exist.` }, { status: Status.NOT_FOUND });
+    return new HttpResponse({ error: true, message: `${req.method} on ${req.url} does not exist.` }, { status: Status.NOT_FOUND });
   };
   handleMethodNotAllowed = async (req) => {
     return new HttpResponse({ error: `${req.method} does not exist.` }, { status: Status.METHOD_NOT_ALLOWED });
   };
-  handlePreflight = async () => {
-    return new HttpResponse("Departed");
-  };
-  handleRoute = async (req) => {
-    const handler = getRouterInstance().getRouteHandler(req);
-    return await handler();
-  };
-  async getResponse(req) {
-    try {
-      if (req.isPreflight) {
-        return await this.handlePreflight();
-      }
-      return await this.handleRoute(req);
-    } catch (err) {
-      if (HttpError.isStatusOf(err, Status.NOT_FOUND)) {
-        return await this.handleNotFound(req);
-      }
-      if (HttpError.isStatusOf(err, Status.METHOD_NOT_ALLOWED)) {
-        return await this.handleMethodNotAllowed(req);
-      }
-      return await this.handleError(err);
-    }
-  }
 }
 
 // src/Server/ServerUsingBun.ts
@@ -170306,9 +170314,8 @@ class ServerUsingBun extends ServerAbstract {
   serve(options) {
     this.app = this.createApp(options);
   }
-  async exit() {
+  async close() {
     await this.app?.stop();
-    process.exit(0);
   }
   createApp(options) {
     return Bun.serve({
@@ -170329,9 +170336,13 @@ class Server extends ServerAbstract {
   serve(options) {
     return this.instance.serve(options);
   }
-  async exit() {
-    await this.handleBeforeExit?.();
-    return await this.instance.exit();
+  async close() {
+    await this.handleBeforeClose?.();
+    console.log("Closing...");
+    await this.instance.close();
+    if (Config.nodeEnv !== "test") {
+      process.exit(0);
+    }
   }
 }
 // src/index.ts

package/package.json

@@ -2,7 +2,7 @@
 	"name": "@ozanarslan/corpus",
 	"type": "module",
 	"module": "index.ts",
-	"version": "0.1.0",
+	"version": "0.1.2",
 	"description": "Small Typescript backend framework with only core utilities",
 	"author": "Ozan Arslan <ozanarslanwork@gmail.com>",
 	"license": "MIT",