@ajke/core 0.1.0

package/src/decorators/core/injectable.decorator.ts

@@ -0,0 +1,41 @@
+import { injectable, inject as tsyringeInject } from "tsyringe";
+import { isForwardRef } from "../../utils/forward-ref.util";
+
+export const INJECT_CUSTOM_TOKENS_KEY = "wilt:inject:custom:tokens";
+
+export function Injectable() {
+	return (target: any) => {
+		injectable()(target);
+	};
+}
+
+export function Inject(token?: any) {
+	return (
+		target: any,
+		propertyKey: string | symbol | undefined,
+		parameterIndex: number
+	) => {
+		if (isForwardRef(token)) {
+			const existing: Record<number, any> =
+				Reflect.getMetadata(INJECT_CUSTOM_TOKENS_KEY, target) || {};
+			existing[parameterIndex] = token;
+			Reflect.defineMetadata(INJECT_CUSTOM_TOKENS_KEY, existing, target);
+			return;
+		}
+
+		if (!token) {
+			const paramTypes = Reflect.getMetadata("design:paramtypes", target) || [];
+			const paramType = paramTypes[parameterIndex];
+			if (paramType) {
+				return tsyringeInject(paramType)(target, propertyKey, parameterIndex);
+			}
+			return;
+		}
+
+		const existing: Record<number, any> =
+			Reflect.getMetadata(INJECT_CUSTOM_TOKENS_KEY, target) || {};
+		existing[parameterIndex] = token;
+		Reflect.defineMetadata(INJECT_CUSTOM_TOKENS_KEY, existing, target);
+		return tsyringeInject(token)(target, propertyKey, parameterIndex);
+	};
+}

package/src/decorators/core/optional.decorator.ts

@@ -0,0 +1,9 @@
+export const OPTIONAL_METADATA = "wilt:optional";
+
+export function Optional(): ParameterDecorator {
+	return (target, _key, parameterIndex) => {
+		const existing: number[] = Reflect.getMetadata(OPTIONAL_METADATA, target) || [];
+		existing.push(parameterIndex);
+		Reflect.defineMetadata(OPTIONAL_METADATA, existing, target);
+	};
+}

package/src/decorators/core/set-metadata.decorator.ts

@@ -0,0 +1,20 @@
+export interface CustomDecorator<TKey = string> {
+	(target: any, key?: any, descriptor?: any): any;
+	KEY: TKey;
+}
+
+export function SetMetadata<K = string, V = any>(
+	metadataKey: K,
+	metadataValue: V
+): CustomDecorator<K> {
+	const decoratorFactory = (target: any, key?: any, descriptor?: PropertyDescriptor): any => {
+		if (descriptor) {
+			Reflect.defineMetadata(metadataKey as string, metadataValue, descriptor.value);
+			return descriptor;
+		}
+		Reflect.defineMetadata(metadataKey as string, metadataValue, target);
+		return target;
+	};
+	(decoratorFactory as any).KEY = metadataKey;
+	return decoratorFactory as CustomDecorator<K>;
+}

package/src/decorators/core/use-guards.decorator.ts

@@ -0,0 +1,14 @@
+export const GUARDS_METADATA = "wilt:guards";
+
+export function UseGuards(...guards: (new (...args: any[]) => any)[]): MethodDecorator & ClassDecorator {
+	return (target: any, key?: any, descriptor?: PropertyDescriptor): any => {
+		if (descriptor) {
+			const existing: any[] = Reflect.getMetadata(GUARDS_METADATA, descriptor.value) || [];
+			Reflect.defineMetadata(GUARDS_METADATA, [...existing, ...guards], descriptor.value);
+			return descriptor;
+		}
+		const existing: any[] = Reflect.getMetadata(GUARDS_METADATA, target) || [];
+		Reflect.defineMetadata(GUARDS_METADATA, [...existing, ...guards], target);
+		return target;
+	};
+}

package/src/decorators/core/use-interceptors.decorator.ts

@@ -0,0 +1,16 @@
+export const INTERCEPTORS_METADATA = "wilt:interceptors";
+
+export function UseInterceptors(
+	...interceptors: (new (...args: any[]) => any)[]
+): MethodDecorator & ClassDecorator {
+	return (target: any, key?: any, descriptor?: PropertyDescriptor): any => {
+		if (descriptor) {
+			const existing: any[] = Reflect.getMetadata(INTERCEPTORS_METADATA, descriptor.value) || [];
+			Reflect.defineMetadata(INTERCEPTORS_METADATA, [...existing, ...interceptors], descriptor.value);
+			return descriptor;
+		}
+		const existing: any[] = Reflect.getMetadata(INTERCEPTORS_METADATA, target) || [];
+		Reflect.defineMetadata(INTERCEPTORS_METADATA, [...existing, ...interceptors], target);
+		return target;
+	};
+}

package/src/decorators/http/controller.decorator.ts

@@ -0,0 +1,230 @@
+import type { Context } from "hono";
+import type { Hono } from "hono";
+import { injectable } from "tsyringe";
+import { createArgumentsHost, createExecutionContext } from "../../context/execution-context";
+import { CATCH_METADATA, FILTERS_METADATA } from "../core/exception-filters.decorator";
+import { GUARDS_METADATA } from "../core/use-guards.decorator";
+import { INTERCEPTORS_METADATA } from "../core/use-interceptors.decorator";
+import { HEADER_METADATA } from "./header.decorator";
+import { HTTP_CODE_METADATA } from "./http-code.decorator";
+import { REDIRECT_METADATA, type RedirectMetadata } from "./redirect.decorator";
+import { ROUTE_PARAMS_METADATA, TOTAL_PARAMS_METADATA, type RouteParamMetadata } from "./route-params.decorator";
+import { ForbiddenException } from "../../exceptions/http-exceptions";
+import type { RouteMetadata } from "../../interfaces/modules/module.interface";
+
+export function Controller(prefix: string = "") {
+	return (target: any) => {
+		injectable()(target);
+		target.prototype.prefix = prefix;
+		target.prototype.constructorParams = target.prototype.constructorParams || [];
+		target.prototype.constructorClass = target;
+	};
+}
+
+function resolveFromRegistry(
+	ClassOrInstance: any,
+	instanceRegistry?: Map<any, any>
+): any {
+	if (typeof ClassOrInstance !== "function") return ClassOrInstance;
+	if (instanceRegistry?.has(ClassOrInstance)) return instanceRegistry.get(ClassOrInstance);
+	return new ClassOrInstance();
+}
+
+async function resolveParamArgs(
+	paramMeta: RouteParamMetadata[],
+	c: Context,
+	totalParams: number
+): Promise<any[]> {
+	const maxIndex = Math.max(totalParams - 1, ...paramMeta.map((p) => p.index));
+	const args = new Array(maxIndex + 1).fill(undefined);
+	const filledIndices = new Set(paramMeta.map((p) => p.index));
+
+	let body: any;
+	const needsBody = paramMeta.some((p) => p.type === "body");
+	if (needsBody) {
+		const ct = c.req.header("content-type") || "";
+		if (ct.includes("multipart/form-data")) {
+			const fd = await c.req.formData();
+			body = {};
+			fd.forEach((v, k) => { body[k] = v; });
+		} else {
+			body = await c.req.json().catch(() => ({}));
+		}
+	}
+
+	for (const p of paramMeta) {
+		switch (p.type) {
+			case "body":
+				args[p.index] = p.data ? body?.[p.data] : body;
+				break;
+			case "param":
+				args[p.index] = p.data ? c.req.param(p.data) : c.req.param();
+				break;
+			case "query":
+				args[p.index] = p.data ? c.req.query(p.data) : c.req.query();
+				break;
+			case "headers":
+				args[p.index] = p.data
+					? c.req.header(p.data)
+					: Object.fromEntries((c.req.raw.headers as any).entries());
+				break;
+			case "ip":
+				args[p.index] =
+					c.req.header("cf-connecting-ip") ||
+					c.req.header("x-forwarded-for") ||
+					"";
+				break;
+			case "req":
+				args[p.index] = c;
+				break;
+		}
+	}
+
+	// Any slot not covered by a decorator receives the raw Hono context
+	for (let i = 0; i <= maxIndex; i++) {
+		if (!filledIndices.has(i)) args[i] = c;
+	}
+
+	return args;
+}
+
+export function registerControllerRoutes(
+	router: Hono<{ Bindings: any }>,
+	controller: any,
+	prefix: string = "",
+	instanceRegistry?: Map<any, any>
+) {
+	const routes: RouteMetadata[] = (controller.constructor as any).prototype.routes || [];
+	const controllerClass = controller.constructor;
+
+	for (const route of routes) {
+		const handlerFn = controller[route.handler as keyof typeof controller] as Function;
+		const fullPath = prefix + route.path;
+		const proto = controllerClass.prototype;
+
+		const classGuards: any[] = Reflect.getMetadata(GUARDS_METADATA, controllerClass) || [];
+		const methodGuards: any[] = Reflect.getMetadata(GUARDS_METADATA, handlerFn) || [];
+		const guards = [...classGuards, ...methodGuards];
+
+		const classInterceptors: any[] = Reflect.getMetadata(INTERCEPTORS_METADATA, controllerClass) || [];
+		const methodInterceptors: any[] = Reflect.getMetadata(INTERCEPTORS_METADATA, handlerFn) || [];
+		const interceptors = [...classInterceptors, ...methodInterceptors];
+
+		const classFilters: any[] = Reflect.getMetadata(FILTERS_METADATA, controllerClass) || [];
+		const methodFilters: any[] = Reflect.getMetadata(FILTERS_METADATA, handlerFn) || [];
+		const filters = [...classFilters, ...methodFilters];
+
+		const httpCode: number | undefined = Reflect.getMetadata(HTTP_CODE_METADATA, handlerFn);
+		const headersToSet: { name: string; value: string }[] =
+			Reflect.getMetadata(HEADER_METADATA, handlerFn) || [];
+		const redirectMeta: RedirectMetadata | undefined = Reflect.getMetadata(REDIRECT_METADATA, handlerFn);
+		const paramMeta: RouteParamMetadata[] =
+			Reflect.getMetadata(ROUTE_PARAMS_METADATA, proto, route.handler) || [];
+		const totalParams: number =
+			Reflect.getMetadata(TOTAL_PARAMS_METADATA, proto, route.handler) ?? 0;
+		const methodMiddlewares: any[] = (handlerFn as any).middlewares || [];
+
+		const finalHandler = async (c: Context): Promise<Response> => {
+			const execCtx = createExecutionContext(c, controllerClass, handlerFn);
+
+			const runCore = async (): Promise<Response> => {
+				// Guards
+				for (const G of guards) {
+					const guard = resolveFromRegistry(G, instanceRegistry);
+					const ok = await guard.canActivate(execCtx);
+					if (!ok) throw new ForbiddenException();
+				}
+
+				// Build the actual call
+				const callHandler = async (): Promise<Response> => {
+					let result: any;
+					if (paramMeta.length > 0) {
+						const args = await resolveParamArgs(paramMeta, c, totalParams);
+						result = await handlerFn.call(controller, ...args);
+					} else {
+						result = await handlerFn.call(controller, c);
+					}
+
+					// Set response headers
+					for (const { name, value } of headersToSet) {
+						c.header(name, value);
+					}
+
+					// Redirect takes precedence
+					if (redirectMeta) {
+						const url =
+							result && typeof result === "object" && "url" in result
+								? (result as any).url
+								: redirectMeta.url;
+						const code =
+							result && typeof result === "object" && "statusCode" in result
+								? (result as any).statusCode
+								: redirectMeta.statusCode;
+						return c.redirect(url, code as any);
+					}
+
+					// Auto-serialize non-Response returns
+					if (result instanceof Response) return result;
+					if (result !== undefined && result !== null) {
+						return c.json(result, (httpCode ?? 200) as any);
+					}
+					return new Response(null, { status: httpCode ?? 204 });
+				};
+
+				// Method-level legacy middlewares
+				if (methodMiddlewares.length > 0) {
+					let idx = 0;
+					const next = async (): Promise<Response | void> => {
+						if (idx < methodMiddlewares.length) {
+							return await methodMiddlewares[idx++](c, next);
+						}
+						return callHandler();
+					};
+					return (await next()) as Response;
+				}
+
+				return callHandler();
+			};
+
+			// Interceptors wrap the core call
+			const runWithInterceptors = async (): Promise<Response> => {
+				if (interceptors.length === 0) return runCore();
+
+				let chain = runCore;
+				for (let i = interceptors.length - 1; i >= 0; i--) {
+					const interceptor = resolveFromRegistry(interceptors[i], instanceRegistry);
+					const inner = chain;
+					chain = () => interceptor.intercept(execCtx, { handle: inner });
+				}
+				return chain();
+			};
+
+			// Exception filters wrap everything
+			if (filters.length === 0) return runWithInterceptors();
+
+			try {
+				return await runWithInterceptors();
+			} catch (err) {
+				for (const F of filters) {
+					const filter = resolveFromRegistry(F, instanceRegistry);
+					const catchTypes: any[] =
+						Reflect.getMetadata(CATCH_METADATA, filter.constructor ?? F) || [];
+					if (catchTypes.length === 0 || catchTypes.some((T) => err instanceof T)) {
+						const host = createArgumentsHost(c);
+						const res = await filter.catch(err, host);
+						if (res instanceof Response) return res;
+					}
+				}
+				throw err;
+			}
+		};
+
+		switch (route.method) {
+			case "GET":    router.get(fullPath, finalHandler);    break;
+			case "POST":   router.post(fullPath, finalHandler);   break;
+			case "PUT":    router.put(fullPath, finalHandler);    break;
+			case "DELETE": router.delete(fullPath, finalHandler); break;
+			case "PATCH":  router.patch(fullPath, finalHandler);  break;
+		}
+	}
+}

package/src/decorators/http/header.decorator.ts

@@ -0,0 +1,11 @@
+export const HEADER_METADATA = "wilt:response-headers";
+
+export function Header(name: string, value: string): MethodDecorator {
+	return (_target, _key, descriptor: PropertyDescriptor) => {
+		const existing: { name: string; value: string }[] =
+			Reflect.getMetadata(HEADER_METADATA, descriptor.value) || [];
+		existing.push({ name, value });
+		Reflect.defineMetadata(HEADER_METADATA, existing, descriptor.value);
+		return descriptor;
+	};
+}

package/src/decorators/http/http-code.decorator.ts

@@ -0,0 +1,8 @@
+export const HTTP_CODE_METADATA = "wilt:http-code";
+
+export function HttpCode(statusCode: number): MethodDecorator {
+	return (_target, _key, descriptor: PropertyDescriptor) => {
+		Reflect.defineMetadata(HTTP_CODE_METADATA, statusCode, descriptor.value);
+		return descriptor;
+	};
+}

package/src/decorators/http/index.ts

@@ -0,0 +1,6 @@
+export * from "./controller.decorator";
+export * from "./route-mapping.decorator";
+export * from "./route-params.decorator";
+export * from "./http-code.decorator";
+export * from "./header.decorator";
+export * from "./redirect.decorator";

package/src/decorators/http/redirect.decorator.ts

@@ -0,0 +1,13 @@
+export const REDIRECT_METADATA = "wilt:redirect";
+
+export interface RedirectMetadata {
+	url: string;
+	statusCode: number;
+}
+
+export function Redirect(url: string, statusCode: number = 302): MethodDecorator {
+	return (_target, _key, descriptor: PropertyDescriptor) => {
+		Reflect.defineMetadata(REDIRECT_METADATA, { url, statusCode }, descriptor.value);
+		return descriptor;
+	};
+}

package/src/decorators/http/route-mapping.decorator.ts

@@ -0,0 +1,22 @@
+function createMethodDecorator(
+	method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH"
+) {
+	return (path: string = "") =>
+		(target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+			if (!target.constructor.prototype.routes) {
+				target.constructor.prototype.routes = [];
+			}
+			target.constructor.prototype.routes.push({
+				method,
+				path,
+				handler: propertyKey,
+			});
+			return descriptor;
+		};
+}
+
+export const Get = createMethodDecorator("GET");
+export const Post = createMethodDecorator("POST");
+export const Put = createMethodDecorator("PUT");
+export const Delete = createMethodDecorator("DELETE");
+export const Patch = createMethodDecorator("PATCH");

package/src/decorators/http/route-params.decorator.ts

@@ -0,0 +1,60 @@
+export const ROUTE_PARAMS_METADATA = "wilt:route-params";
+export const TOTAL_PARAMS_METADATA = "wilt:total-params";
+
+export type RouteParamType = "body" | "param" | "query" | "headers" | "ip" | "req";
+
+export interface RouteParamMetadata {
+	index: number;
+	type: RouteParamType;
+	data?: string;
+}
+
+function recordTotalParams(target: any, key: string) {
+	if (!Reflect.hasMetadata(TOTAL_PARAMS_METADATA, target, key)) {
+		const fn = target[key];
+		if (typeof fn === "function") {
+			Reflect.defineMetadata(TOTAL_PARAMS_METADATA, fn.length, target, key);
+		}
+	}
+}
+
+function createParamDecorator(type: RouteParamType) {
+	return (data?: string): ParameterDecorator =>
+		(target, propertyKey, parameterIndex) => {
+			const key = propertyKey as string;
+			const existing: RouteParamMetadata[] =
+				Reflect.getMetadata(ROUTE_PARAMS_METADATA, target, key) || [];
+			existing.push({ index: parameterIndex, type, data });
+			Reflect.defineMetadata(ROUTE_PARAMS_METADATA, existing, target, key);
+			recordTotalParams(target, key);
+		};
+}
+
+export const Body = createParamDecorator("body");
+export const Param = createParamDecorator("param");
+export const Query = createParamDecorator("query");
+export const Headers = createParamDecorator("headers");
+
+export function Ip(): ParameterDecorator {
+	return (target, propertyKey, parameterIndex) => {
+		const key = propertyKey as string;
+		const existing: RouteParamMetadata[] =
+			Reflect.getMetadata(ROUTE_PARAMS_METADATA, target, key) || [];
+		existing.push({ index: parameterIndex, type: "ip" });
+		Reflect.defineMetadata(ROUTE_PARAMS_METADATA, existing, target, key);
+		recordTotalParams(target, key);
+	};
+}
+
+export function Req(): ParameterDecorator {
+	return (target, propertyKey, parameterIndex) => {
+		const key = propertyKey as string;
+		const existing: RouteParamMetadata[] =
+			Reflect.getMetadata(ROUTE_PARAMS_METADATA, target, key) || [];
+		existing.push({ index: parameterIndex, type: "req" });
+		Reflect.defineMetadata(ROUTE_PARAMS_METADATA, existing, target, key);
+		recordTotalParams(target, key);
+	};
+}
+
+export { Req as Request };

package/src/decorators/index.ts

@@ -0,0 +1,3 @@
+export * from "./core";
+export * from "./http";
+export * from "./modules";

package/src/decorators/modules/global.decorator.ts

@@ -0,0 +1,8 @@
+export const GLOBAL_MODULE_METADATA = "wilt:global";
+
+export function Global(): ClassDecorator {
+	return (target: any) => {
+		Reflect.defineMetadata(GLOBAL_MODULE_METADATA, true, target);
+		return target;
+	};
+}

package/src/decorators/modules/index.ts

@@ -0,0 +1,2 @@
+export * from "./module.decorator";
+export * from "./global.decorator";

package/src/decorators/modules/module.decorator.ts

@@ -0,0 +1,16 @@
+import { injectable } from "tsyringe";
+import type { ModuleMetadata } from "../../interfaces/modules/module.interface";
+
+export function Module(config: ModuleMetadata) {
+	return (target: any) => {
+		target.prototype.moduleConfig = config;
+
+		if (config.providers) {
+			config.providers.forEach((ProviderClass: any) => {
+				if (ProviderClass && typeof ProviderClass === "function") {
+					injectable()(ProviderClass);
+				}
+			});
+		}
+	};
+}

package/src/exceptions/http-exception.ts

@@ -0,0 +1,17 @@
+export class HttpException extends Error {
+	constructor(
+		private readonly response: string | Record<string, any>,
+		private readonly statusCode: number
+	) {
+		super(typeof response === "string" ? response : (response as any).message ?? "HttpException");
+		this.name = "HttpException";
+	}
+
+	getStatus(): number {
+		return this.statusCode;
+	}
+
+	getResponse(): string | Record<string, any> {
+		return this.response;
+	}
+}

package/src/exceptions/http-exceptions.ts

@@ -0,0 +1,85 @@
+import { HttpException } from "./http-exception";
+
+export class BadRequestException extends HttpException {
+	constructor(message: string | Record<string, any> = "Bad Request") {
+		super(message, 400);
+		this.name = "BadRequestException";
+	}
+}
+
+export class UnauthorizedException extends HttpException {
+	constructor(message: string | Record<string, any> = "Unauthorized") {
+		super(message, 401);
+		this.name = "UnauthorizedException";
+	}
+}
+
+export class ForbiddenException extends HttpException {
+	constructor(message: string | Record<string, any> = "Forbidden") {
+		super(message, 403);
+		this.name = "ForbiddenException";
+	}
+}
+
+export class NotFoundException extends HttpException {
+	constructor(message: string | Record<string, any> = "Not Found") {
+		super(message, 404);
+		this.name = "NotFoundException";
+	}
+}
+
+export class MethodNotAllowedException extends HttpException {
+	constructor(message: string | Record<string, any> = "Method Not Allowed") {
+		super(message, 405);
+		this.name = "MethodNotAllowedException";
+	}
+}
+
+export class ConflictException extends HttpException {
+	constructor(message: string | Record<string, any> = "Conflict") {
+		super(message, 409);
+		this.name = "ConflictException";
+	}
+}
+
+export class GoneException extends HttpException {
+	constructor(message: string | Record<string, any> = "Gone") {
+		super(message, 410);
+		this.name = "GoneException";
+	}
+}
+
+export class UnprocessableEntityException extends HttpException {
+	constructor(message: string | Record<string, any> = "Unprocessable Entity") {
+		super(message, 422);
+		this.name = "UnprocessableEntityException";
+	}
+}
+
+export class TooManyRequestsException extends HttpException {
+	constructor(message: string | Record<string, any> = "Too Many Requests") {
+		super(message, 429);
+		this.name = "TooManyRequestsException";
+	}
+}
+
+export class InternalServerErrorException extends HttpException {
+	constructor(message: string | Record<string, any> = "Internal Server Error") {
+		super(message, 500);
+		this.name = "InternalServerErrorException";
+	}
+}
+
+export class NotImplementedException extends HttpException {
+	constructor(message: string | Record<string, any> = "Not Implemented") {
+		super(message, 501);
+		this.name = "NotImplementedException";
+	}
+}
+
+export class ServiceUnavailableException extends HttpException {
+	constructor(message: string | Record<string, any> = "Service Unavailable") {
+		super(message, 503);
+		this.name = "ServiceUnavailableException";
+	}
+}

package/src/exceptions/index.ts

@@ -0,0 +1,2 @@
+export * from "./http-exception";
+export * from "./http-exceptions";

package/src/index.ts

@@ -0,0 +1,11 @@
+export * from "./decorators";
+export * from "./injector";
+export * from "./interfaces";
+export * from "./middleware";
+export * from "./pipes";
+export * from "./exceptions";
+export * from "./context";
+export * from "./services";
+export * from "./utils/forward-ref.util";
+export * from "./utils/response.util";
+export * from "./utils/apply-decorators.util";

package/src/injector/index.ts

@@ -0,0 +1 @@
+export * from "./module.factory";