npm - @tahminator/sapling - Versions diffs - 1.5.27 → 1.5.28-beta.7e624925 - Mend

@tahminator/sapling 1.5.27 → 1.5.28-beta.7e624925

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (51) hide show

package/dist/index.cjs +755 -0
package/dist/index.d.cts +521 -0
package/dist/index.d.mts +521 -0
package/dist/index.mjs +701 -0
package/package.json +15 -10
package/dist/eslint.config.d.ts +0 -2
package/dist/eslint.config.js +0 -38
package/dist/exclusions.d.ts +0 -5
package/dist/exclusions.js +0 -6
package/dist/index.d.ts +0 -1
package/dist/index.js +0 -1
package/dist/lib/weakmap.d.ts +0 -15
package/dist/lib/weakmap.js +0 -77
package/dist/src/__test__/first.d.ts +0 -6
package/dist/src/__test__/first.js +0 -20
package/dist/src/__test__/second.d.ts +0 -6
package/dist/src/__test__/second.js +0 -20
package/dist/src/annotation/controller.d.ts +0 -21
package/dist/src/annotation/controller.js +0 -78
package/dist/src/annotation/index.d.ts +0 -4
package/dist/src/annotation/index.js +0 -4
package/dist/src/annotation/injectable.d.ts +0 -25
package/dist/src/annotation/injectable.js +0 -72
package/dist/src/annotation/middleware.d.ts +0 -9
package/dist/src/annotation/middleware.js +0 -11
package/dist/src/annotation/route.d.ts +0 -47
package/dist/src/annotation/route.js +0 -77
package/dist/src/enum/http.d.ts +0 -68
package/dist/src/enum/http.js +0 -71
package/dist/src/enum/index.d.ts +0 -1
package/dist/src/enum/index.js +0 -1
package/dist/src/helper/error.d.ts +0 -10
package/dist/src/helper/error.js +0 -19
package/dist/src/helper/index.d.ts +0 -4
package/dist/src/helper/index.js +0 -4
package/dist/src/helper/redirect.d.ts +0 -14
package/dist/src/helper/redirect.js +0 -19
package/dist/src/helper/response.d.ts +0 -68
package/dist/src/helper/response.js +0 -90
package/dist/src/helper/sapling.d.ts +0 -101
package/dist/src/helper/sapling.js +0 -153
package/dist/src/html/404.d.ts +0 -4
package/dist/src/html/404.js +0 -14
package/dist/src/html/index.d.ts +0 -1
package/dist/src/html/index.js +0 -1
package/dist/src/index.d.ts +0 -5
package/dist/src/index.js +0 -5
package/dist/src/types.d.ts +0 -21
package/dist/src/types.js +0 -11
package/dist/vite.config.d.ts +0 -2
package/dist/vite.config.js +0 -18

package/dist/index.cjs ADDED Viewed

@@ -0,0 +1,755 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let express = require("express");
+express = __toESM(express);
+//#region src/html/404.ts
+/**
+* Default Express.js 404 error page, as a string.
+*/
+const Html404ErrorPage = (error) => `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Error</title>
+</head>
+<body>
+<pre>${error}</pre>
+</body>
+</html>
+`;
+//#endregion
+//#region src/helper/redirect.ts
+/**
+* Generic HTTP redirect wrapped modeled after Spring's `RedirectView`.
+*
+* You can either return `new RedirectView(url)` or `RedirectView.redirect(url)` inside of a controller method.
+*/
+var RedirectView = class RedirectView {
+	constructor(url) {
+		this._url = url;
+	}
+	getUrl() {
+		return this._url;
+	}
+	/**
+	* Instantiate `RedirectView` with the given `url`.
+	*/
+	static redirect(url) {
+		return new RedirectView(url);
+	}
+};
+//#endregion
+//#region src/enum/http.ts
+/**
+* Enum of every valid HTTP status code mapped to a specific enum member.
+*
+* @see {@link ResponseEntity}
+*/
+let HttpStatus = /* @__PURE__ */ function(HttpStatus) {
+	HttpStatus[HttpStatus["CONTINUE"] = 100] = "CONTINUE";
+	HttpStatus[HttpStatus["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+	HttpStatus[HttpStatus["PROCESSING"] = 102] = "PROCESSING";
+	HttpStatus[HttpStatus["EARLY_HINTS"] = 103] = "EARLY_HINTS";
+	HttpStatus[HttpStatus["OK"] = 200] = "OK";
+	HttpStatus[HttpStatus["CREATED"] = 201] = "CREATED";
+	HttpStatus[HttpStatus["ACCEPTED"] = 202] = "ACCEPTED";
+	HttpStatus[HttpStatus["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+	HttpStatus[HttpStatus["NO_CONTENT"] = 204] = "NO_CONTENT";
+	HttpStatus[HttpStatus["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+	HttpStatus[HttpStatus["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+	HttpStatus[HttpStatus["MULTI_STATUS"] = 207] = "MULTI_STATUS";
+	HttpStatus[HttpStatus["ALREADY_REPORTED"] = 208] = "ALREADY_REPORTED";
+	HttpStatus[HttpStatus["IM_USED"] = 226] = "IM_USED";
+	HttpStatus[HttpStatus["MULTIPLE_CHOICES"] = 300] = "MULTIPLE_CHOICES";
+	HttpStatus[HttpStatus["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+	HttpStatus[HttpStatus["FOUND"] = 302] = "FOUND";
+	HttpStatus[HttpStatus["SEE_OTHER"] = 303] = "SEE_OTHER";
+	HttpStatus[HttpStatus["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+	HttpStatus[HttpStatus["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+	HttpStatus[HttpStatus["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+	HttpStatus[HttpStatus["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+	HttpStatus[HttpStatus["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+	HttpStatus[HttpStatus["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+	HttpStatus[HttpStatus["FORBIDDEN"] = 403] = "FORBIDDEN";
+	HttpStatus[HttpStatus["NOT_FOUND"] = 404] = "NOT_FOUND";
+	HttpStatus[HttpStatus["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+	HttpStatus[HttpStatus["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+	HttpStatus[HttpStatus["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+	HttpStatus[HttpStatus["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+	HttpStatus[HttpStatus["CONFLICT"] = 409] = "CONFLICT";
+	HttpStatus[HttpStatus["GONE"] = 410] = "GONE";
+	HttpStatus[HttpStatus["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+	HttpStatus[HttpStatus["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+	HttpStatus[HttpStatus["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+	HttpStatus[HttpStatus["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+	HttpStatus[HttpStatus["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+	HttpStatus[HttpStatus["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
+	HttpStatus[HttpStatus["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+	HttpStatus[HttpStatus["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+	HttpStatus[HttpStatus["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+	HttpStatus[HttpStatus["LOCKED"] = 423] = "LOCKED";
+	HttpStatus[HttpStatus["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+	HttpStatus[HttpStatus["TOO_EARLY"] = 425] = "TOO_EARLY";
+	HttpStatus[HttpStatus["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
+	HttpStatus[HttpStatus["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+	HttpStatus[HttpStatus["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+	HttpStatus[HttpStatus["REQUEST_HEADER_FIELDS_TOO_LARGE"] = 431] = "REQUEST_HEADER_FIELDS_TOO_LARGE";
+	HttpStatus[HttpStatus["UNAVAILABLE_FOR_LEGAL_REASONS"] = 451] = "UNAVAILABLE_FOR_LEGAL_REASONS";
+	HttpStatus[HttpStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+	HttpStatus[HttpStatus["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+	HttpStatus[HttpStatus["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+	HttpStatus[HttpStatus["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+	HttpStatus[HttpStatus["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+	HttpStatus[HttpStatus["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+	HttpStatus[HttpStatus["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
+	HttpStatus[HttpStatus["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
+	HttpStatus[HttpStatus["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
+	HttpStatus[HttpStatus["BANDWIDTH_LIMIT_EXCEEDED"] = 509] = "BANDWIDTH_LIMIT_EXCEEDED";
+	HttpStatus[HttpStatus["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
+	HttpStatus[HttpStatus["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
+	return HttpStatus;
+}({});
+//#endregion
+//#region src/helper/response.ts
+/**
+* Generic HTTP response wrapper modeled after Spring's `ResponseEntity`.
+*
+* Provides status code, headers, and an optional typed body.
+* The body is serialized through `Sapling.serialize`.
+*
+* @typeParam T - the type of the response body
+*/
+var ResponseEntity = class {
+	constructor(body, headers = {}, statusCode = 200) {
+		this._headers = {};
+		this._body = body;
+		this._headers = headers;
+		this._statusCode = statusCode;
+	}
+	/**
+	* Create a builder with a 200 status code.
+	*
+	* @example```ts
+	* return ResponseEntity.ok().body({ success: true });
+	* ```
+	*/
+	static ok() {
+		return new ResponseEntityBuilder(200);
+	}
+	/**
+	* Create a builder with a custom status code.
+	*
+	* @example```ts
+	* return ResponseEntity.status(HttpStatus.BAD_REQUEST).body({ success: false });
+	* ```
+	*
+	* @see {@link HttpStatus}
+	*/
+	static status(statusCode) {
+		return new ResponseEntityBuilder(statusCode);
+	}
+	/**
+	* Return status code.
+	*/
+	getStatusCode() {
+		return this._statusCode;
+	}
+	/**
+	* Return headers.
+	*/
+	getHeaders() {
+		return this._headers;
+	}
+	/**
+	* Return the response body.
+	*/
+	getBody() {
+		return this._body;
+	}
+};
+/**
+* Builder for {@link ResponseEntity}.
+*
+* Forces the status code to be set first, then headers and body,
+* ensuring type safety when constructing the response.
+*/
+var ResponseEntityBuilder = class {
+	constructor(statusCode) {
+		this._headers = {};
+		this._statusCode = statusCode;
+	}
+	/**
+	* Set all headers as an object with keys and values.
+	*/
+	headers(headers) {
+		this._headers = headers;
+		return this;
+	}
+	/**
+	* Add/override a single key and value to the headers.
+	*/
+	setHeader(key, value) {
+		this._headers[key] = value;
+		return this;
+	}
+	/**
+	* Set the response body.
+	*/
+	body(body) {
+		return new ResponseEntity(body, this._headers, this._statusCode);
+	}
+};
+//#endregion
+//#region src/helper/error/responsestatus.ts
+/**
+* Ensure that you define a middleware that can handle this error.
+*
+* @see {@link Sapling.loadResponseStatusErrorMiddleware}
+*/
+var ResponseStatusError = class ResponseStatusError extends Error {
+	constructor(status, message) {
+		super(message ?? "Something went wrong.");
+		this.status = status;
+		Object.setPrototypeOf(this, new.target.prototype);
+		this.name = `HttpError(${HttpStatus[status]})`;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, ResponseStatusError);
+	}
+};
+//#endregion
+//#region src/helper/sapling.ts
+const settings = {
+	serialize: JSON.stringify,
+	deserialize: JSON.parse
+};
+/**
+* Collection of utility functions which are essential for Sapling to function.
+*/
+var Sapling = class Sapling {
+	/**
+	* If you would prefer to manually resolve your controllers instead, call resolve
+	* on the controller class.
+	*
+	* @example```ts
+	* import { Sapling } from "@tahminator/sapling";
+	* import TestController from "./path/to/test.controller";
+	*
+	* const app = express();
+	*
+	* const router = Sapling.resolve(TestController);
+	* app.use(router);
+	* ```
+	*/
+	static resolve(clazz) {
+		const router = _ControllerRegistry.get(clazz);
+		if (!router) throw new Error("Controller cannot be found");
+		return router;
+	}
+	/**
+	* Register this function as a middleware in order to utilize Sapling's `deserialize` function.
+	*
+	* @example```ts
+	* import { Sapling } from "@tahminator/sapling";
+	* import express from "express";
+	*
+	* const app = express();
+	*
+	* app.use(Sapling.json());
+	* ```
+	*/
+	static json() {
+		return (request, _response, next) => {
+			try {
+				if (!request.body) return next();
+				if (request.headers["content-type"] !== "application/json") return next();
+				if (typeof request.body === "string") request.body = Sapling.deserialize(request.body);
+				else if (typeof request.body === "object") {
+					const raw = JSON.stringify(request.body);
+					request.body = Sapling.deserialize(raw);
+				}
+				next();
+			} catch (err) {
+				next(err);
+			}
+		};
+	}
+	/**
+	* Register your application with all the necessary middlewares and logics for Sapling to function.
+	*
+	* @example```ts
+	* import { Sapling } from "@tahminator/sapling";
+	* import express from "express";
+	*
+	* const app = express();
+	*
+	* app.registerApp(app);
+	* ```
+	*/
+	static registerApp(app) {
+		app.use(express.default.text({ type: "application/json" }));
+		app.use(Sapling.json());
+	}
+	/**
+	* Register a middleware that will handle {@link ResponseStatusError}.
+	*
+	* This middleware will chain to the next middleware if it does not catch {@link ResponseStatusError}.
+	* You may still define middleware to handle all other errors in a separate `app.use` call.
+	*
+	* @example
+	* ```ts
+	* import express from "express";
+	* import { Sapling } from "@tahminator/sapling";
+	*
+	* const app = express();
+	*
+	* Sapling.loadResponseStatusErrorMiddleware(app, (err, req, res, next) => {
+	*   // `err` is guaranteed to be of type ResponseStatusError
+	*   res.status(err.status).json({
+	*     success: false,
+	*     message: err.message,
+	*   });
+	* });
+	* ```
+	*/
+	static loadResponseStatusErrorMiddleware(app, fn) {
+		app.use(((err, req, res, next) => {
+			if (err instanceof ResponseStatusError) fn(err, req, res, next);
+			else next(err);
+		}));
+	}
+	/**
+	* Serialize a value into a JSON string.
+	*
+	* This function is used in {@link ResponseEntity} to serialize the `body`.
+	*
+	* Use `setSerializeFn` to override underlying implementation.
+	*
+	* @defaultValue `JSON.stringify`
+	*/
+	static serialize(value) {
+		return settings.serialize(value);
+	}
+	/**
+	* Replace the function used for `serialize`.
+	*/
+	static setSerializeFn(fn) {
+		settings.serialize = fn;
+	}
+	/**
+	* De-serialize a JSON string back to a JavaScript object.
+	*
+	* This function is used to de-serialize a string into a `body`.
+	*
+	* Use `setDeserializeFn` to override underlying implementation.
+	*
+	* @defaultValue `JSON.parse`
+	*/
+	static deserialize(value) {
+		return settings.deserialize(value);
+	}
+	/**
+	* Replace the function used for `deserialize`
+	*/
+	static setDeserializeFn(fn) {
+		settings.deserialize = fn;
+	}
+};
+//#endregion
+//#region src/types.ts
+const methodResolve = {
+	GET: "get",
+	PUT: "put",
+	POST: "post",
+	DELETE: "delete",
+	OPTIONS: "options",
+	PATCH: "patch",
+	HEAD: "head",
+	USE: "use"
+};
+//#endregion
+//#region lib/weakmap.ts
+/**
+* WeakMap that is iterable.
+*/
+var IterableWeakMap = class IterableWeakMap {
+	#weakMap = /* @__PURE__ */ new WeakMap();
+	#refSet = /* @__PURE__ */ new Set();
+	#finalizationGroup = new FinalizationRegistry(IterableWeakMap.#cleanup);
+	static #cleanup(heldValue) {
+		heldValue.set.delete(heldValue.ref);
+	}
+	constructor(iterable) {
+		if (iterable) for (const [key, value] of iterable) this.set(key, value);
+	}
+	set(key, value) {
+		const ref = new WeakRef(key);
+		this.#weakMap.set(key, {
+			value,
+			ref
+		});
+		this.#refSet.add(ref);
+		this.#finalizationGroup.register(key, {
+			set: this.#refSet,
+			ref
+		}, ref);
+		return this;
+	}
+	get(key) {
+		return this.#weakMap.get(key)?.value;
+	}
+	delete(key) {
+		const entry = this.#weakMap.get(key);
+		if (!entry) return false;
+		this.#weakMap.delete(key);
+		this.#refSet.delete(entry.ref);
+		this.#finalizationGroup.unregister(entry.ref);
+		return true;
+	}
+	*[Symbol.iterator]() {
+		for (const ref of this.#refSet) {
+			const key = ref.deref();
+			if (!key) continue;
+			const entry = this.#weakMap.get(key);
+			if (entry) yield [key, entry.value];
+		}
+	}
+	entries() {
+		return this[Symbol.iterator]();
+	}
+	*keys() {
+		for (const [key] of this) yield key;
+	}
+	*values() {
+		for (const [, value] of this) yield value;
+	}
+	forEach(callback, thisArg) {
+		for (const [key, value] of this) callback.call(thisArg, value, key, this);
+	}
+};
+//#endregion
+//#region src/annotation/injectable.ts
+const _InjectableRegistry = /* @__PURE__ */ new WeakMap();
+const _InjectableDeps = new IterableWeakMap();
+/**
+* Mark the class as an injectable to be handled by Sapling. The class can now be
+* be injected into other classes, as well as allow the class to inject other `@Injectable` classes.
+*
+* @argument deps - An optional array to define any dependencies that this class may require.
+*/
+function Injectable(deps = []) {
+	return function(target) {
+		_InjectableRegistry.set(target, null);
+		_InjectableDeps.set(target, deps);
+	};
+}
+/**
+* Resolves and instantiates a class along with all of it's transitive dependencies.
+*
+* Uses topological sort (Kahn's algorithm) to ensure that the dependency graph is created
+* in a correct order.
+*
+* When `resolve` is first called (usually during controller registration),
+* it will compute the dependency graph of all `@Injectable` classes and instantiates
+* them in the correct order.
+*
+* Subsequent calls to dependencies that have already been resolved are cached, so they will
+* re-use the created singletons instead of re-instantiation.
+*/
+function _resolve(ctor) {
+	const inDegree = /* @__PURE__ */ new Map();
+	const graph = /* @__PURE__ */ new Map();
+	_InjectableDeps.forEach((deps, node) => {
+		inDegree.set(node, inDegree.get(node) || 0);
+		deps.forEach((dep) => {
+			if (dep === void 0) throw new Error(`There is an @Injectable (${node.name}) which has a dependency that cannot be found. This is likely caused by a circular dependency.`);
+			inDegree.set(dep, inDegree.get(dep) || 0);
+			inDegree.set(node, inDegree.get(node) + 1);
+			if (!graph.has(dep)) graph.set(dep, []);
+			graph.get(dep).push(node);
+		});
+	});
+	const queue = [];
+	inDegree.forEach((deg, node) => {
+		if (deg === 0) queue.push(node);
+	});
+	while (queue.length) {
+		const current = queue.shift();
+		if (!_InjectableRegistry.get(current)) {
+			const instance = new current(...(_InjectableDeps.get(current) || []).map((dep) => _InjectableRegistry.get(dep)));
+			_InjectableRegistry.set(current, instance);
+		}
+		(graph.get(current) || []).forEach((neighbor) => {
+			inDegree.set(neighbor, (inDegree.get(neighbor) ?? 0) - 1);
+			if (inDegree.get(neighbor) === 0) queue.push(neighbor);
+		});
+	}
+	if (!_InjectableRegistry.get(ctor)) throw new Error("Circular dependency detected or injectable not registered");
+	return _InjectableRegistry.get(ctor);
+}
+//#endregion
+//#region src/helper/error/exception.ts
+/**
+* This error should be thrown when some data cannot be parsed by a given schema.
+*/
+var ParserError = class ParserError extends ResponseStatusError {
+	constructor(location, issues, vendor) {
+		super(400, ParserError.formatMessage(location, issues, vendor));
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+	static formatMessage(location, issues, vendor) {
+		const formatted = issues.map((i) => {
+			const path = Array.isArray(i.path) ? i.path.map((seg) => typeof seg === "object" && seg ? String(seg.key) : String(seg)).join(".") : "";
+			return path ? `${path}: ${i.message}` : i.message;
+		}).join("; ");
+		return `${vendor} failed to parse ${(() => {
+			switch (location) {
+				case "reqbody": return "request body";
+				case "reqparams": return "request params";
+				case "reqquery": return "request query";
+			}
+		})()}: ${formatted}`;
+	}
+};
+//#endregion
+//#region src/annotation/request.ts
+const _requestSchemaStore = /* @__PURE__ */ new WeakMap();
+function _getOrCreateRequestSchemaDefinition(ctor, fnName) {
+	const byFn = (() => {
+		const fn = _requestSchemaStore.get(ctor);
+		if (fn) return fn;
+		const newFn = /* @__PURE__ */ new Map();
+		_requestSchemaStore.set(ctor, newFn);
+		return newFn;
+	})();
+	const existing = byFn.get(fnName);
+	if (existing) return existing;
+	const created = {};
+	byFn.set(fnName, created);
+	return created;
+}
+function _setOnce(def, key, schema, fnName) {
+	if (def[key]) throw new Error(`Duplicate request schema for "${String(key)}" on method "${fnName}"`);
+	def[key] = schema;
+}
+function RequestBody(schema) {
+	return (target, propertyKey) => {
+		const ctor = target.constructor;
+		const fnName = String(propertyKey);
+		_setOnce(_getOrCreateRequestSchemaDefinition(ctor, fnName), "body", schema, fnName);
+	};
+}
+function RequestParam(schema) {
+	return (target, propertyKey) => {
+		const ctor = target.constructor;
+		const fnName = String(propertyKey);
+		_setOnce(_getOrCreateRequestSchemaDefinition(ctor, fnName), "param", schema, fnName);
+	};
+}
+function RequestQuery(schema) {
+	return (target, propertyKey) => {
+		const ctor = target.constructor;
+		const fnName = String(propertyKey);
+		_setOnce(_getOrCreateRequestSchemaDefinition(ctor, fnName), "query", schema, fnName);
+	};
+}
+function _getRequestSchemas(ctor, fnName) {
+	return _requestSchemaStore.get(ctor)?.get(fnName);
+}
+async function _parseOrThrow(schema, input, kind) {
+	const result = await schema["~standard"].validate(input);
+	if (result.issues) throw new ParserError(kind, result.issues, schema["~standard"].vendor);
+	return result.value;
+}
+//#endregion
+//#region src/annotation/route.ts
+const _routeStore = /* @__PURE__ */ new WeakMap();
+/**
+* Custom annotation that will store all routes inside of a map,
+* which can then be used to initialize all the routes to the router.
+*/
+function _Route({ method, path = "" }) {
+	return (target, propertyKey) => {
+		const ctor = target.constructor;
+		const list = _routeStore.get(ctor) ?? [];
+		list.push({
+			method,
+			path: path ?? "",
+			fnName: String(propertyKey)
+		});
+		_routeStore.set(ctor, list);
+	};
+}
+/**
+* Register GET route on the given path (default "") for the given controller.
+*/
+const GET = (path = "") => _Route({
+	method: "GET",
+	path
+});
+/**
+* Register POST route on the given path (default "") for the given controller.
+*/
+const POST = (path = "") => _Route({
+	method: "POST",
+	path
+});
+/**
+* Register PUT route on the given path (default "") for the given controller.
+*/
+const PUT = (path = "") => _Route({
+	method: "PUT",
+	path
+});
+/**
+* Register DELETE route on the given path (default "") for the given controller.
+*/
+const DELETE = (path = "") => _Route({
+	method: "DELETE",
+	path
+});
+/**
+* Register OPTIONS route on the given path (default "") for the given controller.
+*/
+const OPTIONS = (path = "") => _Route({
+	method: "OPTIONS",
+	path
+});
+/**
+* Register PATCH route on the given path (default "") for the given controller.
+*/
+const PATCH = (path = "") => _Route({
+	method: "PATCH",
+	path
+});
+/**
+* Register HEAD route on the given path (default "") for the given controller.
+*/
+const HEAD = (path = "") => _Route({
+	method: "HEAD",
+	path
+});
+/**
+* Register a middleware route on the given path (default "") for the given controller.
+*/
+const Middleware = (path = "") => _Route({
+	method: "USE",
+	path
+});
+/**
+* Given a class constructor, fetch all the routes attached.
+*/
+function _getRoutes(ctor) {
+	return _routeStore.get(ctor) ?? [];
+}
+//#endregion
+//#region src/annotation/controller.ts
+const _ControllerRegistry = /* @__PURE__ */ new WeakMap();
+/**
+* Registers a class as an HTTP controller and registers its routes.
+*
+* @param [prefix] Optional URL prefix applied to all routes in the controller. Defaults to "".
+* @param [deps] Optional array of dependencies to be injected into the constructor that are `@Injectable`
+*/
+function Controller({ prefix = "", deps = [] } = {}) {
+	return (target) => {
+		const targetClass = target;
+		const router = (0, express.Router)();
+		const routes = _getRoutes(target);
+		const usedRoutes = /* @__PURE__ */ new Set();
+		_InjectableDeps.set(targetClass, deps);
+		const controllerInstance = _resolve(targetClass);
+		for (const { method, path, fnName } of routes) {
+			const fn = controllerInstance[fnName];
+			if (typeof fn !== "function") continue;
+			const fp = path instanceof RegExp ? path : prefix + path;
+			const routeKey = method + " " + (path instanceof RegExp ? path.source : fp);
+			if (method !== "USE" && usedRoutes.has(routeKey)) throw new Error(`Duplicate route [${method}] "${path instanceof RegExp ? path.source : fp}" detected in controller "${target.name}"`);
+			if (method !== "USE") usedRoutes.add(routeKey);
+			const methodName = methodResolve[method];
+			router[methodName](fp, async (request, response, next) => {
+				const schemas = _getRequestSchemas(target, fnName);
+				if (schemas) {
+					if (schemas.body) request.body = await _parseOrThrow(schemas.body, request.body, "reqbody");
+					if (schemas.param) request.params = await _parseOrThrow(schemas.param, request.params, "reqparams");
+					if (schemas.query) request.query = await _parseOrThrow(schemas.query, request.query, "reqquery");
+				}
+				const result = await fn.bind(controllerInstance)(request, response, next);
+				if (method === "USE") return;
+				if (result instanceof ResponseEntity) {
+					response.contentType("application/json").status(result.getStatusCode()).set(result.getHeaders()).send(Sapling.serialize(result.getBody()));
+					return;
+				}
+				if (result instanceof RedirectView) {
+					response.redirect(result.getUrl());
+					return;
+				}
+				if (!response.writableEnded) response.status(404).send(Html404ErrorPage(`Cannot ${methodName.toUpperCase()} ${path instanceof RegExp ? path.source : fp}`));
+			});
+		}
+		_ControllerRegistry.set(targetClass, router);
+	};
+}
+//#endregion
+//#region src/annotation/middleware.ts
+/**
+* Used to define a middleware-only class.
+*
+* __NOTE:__ `@MiddlewareClass` works exactly the same as `@Controller`. As such, you
+* can still register `@Route` and `@Middleware` methods, though you very well should not
+* for the sake of semantics.
+*/
+function MiddlewareClass(...args) {
+	return Controller(...args);
+}
+//#endregion
+exports.Controller = Controller;
+exports.DELETE = DELETE;
+exports.GET = GET;
+exports.HEAD = HEAD;
+exports.Html404ErrorPage = Html404ErrorPage;
+exports.HttpStatus = HttpStatus;
+exports.Injectable = Injectable;
+exports.Middleware = Middleware;
+exports.MiddlewareClass = MiddlewareClass;
+exports.OPTIONS = OPTIONS;
+exports.PATCH = PATCH;
+exports.POST = POST;
+exports.PUT = PUT;
+exports.ParserError = ParserError;
+exports.RedirectView = RedirectView;
+exports.RequestBody = RequestBody;
+exports.RequestParam = RequestParam;
+exports.RequestQuery = RequestQuery;
+exports.ResponseEntity = ResponseEntity;
+exports.ResponseEntityBuilder = ResponseEntityBuilder;
+exports.ResponseStatusError = ResponseStatusError;
+exports.Sapling = Sapling;
+exports._ControllerRegistry = _ControllerRegistry;
+exports._InjectableDeps = _InjectableDeps;
+exports._InjectableRegistry = _InjectableRegistry;
+exports._Route = _Route;
+exports._getRequestSchemas = _getRequestSchemas;
+exports._getRoutes = _getRoutes;
+exports._parseOrThrow = _parseOrThrow;
+exports._resolve = _resolve;
+exports.methodResolve = methodResolve;