@ajke/core 0.1.0

package/src/injector/injector.ts

@@ -0,0 +1,103 @@
+import { INJECT_CUSTOM_TOKENS_KEY } from "../decorators/core/injectable.decorator";
+import { OPTIONAL_METADATA } from "../decorators/core/optional.decorator";
+import { isForwardRef } from "../utils/forward-ref.util";
+import { logger } from "../utils/logger.util";
+
+function createCircularProxy(registry: Map<any, any>, tokenClass: any): any {
+	return new Proxy(
+		{},
+		{
+			get(_target, prop) {
+				const instance = registry.get(tokenClass);
+				if (!instance) {
+					throw new Error(
+						`[Wilt DI] Circular dependency proxy for "${tokenClass.name}" ` +
+							`was accessed before the real instance was created. ` +
+							`Make sure both sides use @Inject(forwardRef(() => ...)).`
+					);
+				}
+				const val = (instance as any)[prop];
+				return typeof val === "function" ? val.bind(instance) : val;
+			},
+			set(_target, prop, value) {
+				const instance = registry.get(tokenClass);
+				if (instance) (instance as any)[prop] = value;
+				return true;
+			},
+		}
+	);
+}
+
+export function resolveInstance(
+	ProviderClass: any,
+	instanceRegistry: Map<any, any>,
+	inProgress: Set<any>
+): any {
+	if (instanceRegistry.has(ProviderClass)) {
+		return instanceRegistry.get(ProviderClass);
+	}
+
+	if (inProgress.has(ProviderClass)) {
+		logger.warn(
+			`Circular dependency detected for "${ProviderClass.name}". ` +
+				`Injecting a lazy proxy — ensure forwardRef() is used on both sides.`,
+			"ModuleFactory"
+		);
+		return createCircularProxy(instanceRegistry, ProviderClass);
+	}
+
+	inProgress.add(ProviderClass);
+
+	const paramTypes: any[] =
+		Reflect.getMetadata("design:paramtypes", ProviderClass) || [];
+	const customTokens: Record<number, any> =
+		Reflect.getMetadata(INJECT_CUSTOM_TOKENS_KEY, ProviderClass) || {};
+	const optionalIndices: number[] =
+		Reflect.getMetadata(OPTIONAL_METADATA, ProviderClass) || [];
+
+	const customIndices = Object.keys(customTokens).map(Number);
+	const paramCount = Math.max(
+		paramTypes.length,
+		customIndices.length > 0 ? Math.max(...customIndices) + 1 : 0
+	);
+
+	const deps = Array.from({ length: paramCount }, (_, i) => {
+		const customToken = customTokens[i];
+		const paramType = paramTypes[i];
+		const isOptional = optionalIndices.includes(i);
+
+		let actualClass: any;
+		if (customToken) {
+			actualClass = isForwardRef(customToken)
+				? customToken.forwardRef()
+				: customToken;
+		} else {
+			actualClass = paramType;
+		}
+
+		if (!actualClass || actualClass === Object || actualClass === Function) {
+			if (!isOptional) {
+				logger.warn(
+					`Cannot resolve param[${i}] for "${ProviderClass.name}": ` +
+						`no type info. Use @Inject(TheClass) to specify it explicitly.`,
+					"ModuleFactory"
+				);
+			}
+			return undefined;
+		}
+
+		try {
+			return resolveInstance(actualClass, instanceRegistry, inProgress);
+		} catch (err) {
+			if (isOptional) return undefined;
+			throw err;
+		}
+	});
+
+	const instance = new ProviderClass(...deps);
+	instanceRegistry.set(ProviderClass, instance);
+	inProgress.delete(ProviderClass);
+
+	logger.debug(`Created instance: ${ProviderClass.name}`, "ModuleFactory");
+	return instance;
+}

package/src/injector/module-compiler.ts

@@ -0,0 +1,48 @@
+import { GLOBAL_MODULE_METADATA } from "../decorators/modules/global.decorator";
+import { isForwardRef } from "../utils/forward-ref.util";
+
+export function collectModuleTree(
+	moduleClass: any,
+	visiting: Set<any>,
+	visited: Set<any>,
+	controllers: any[],
+	providers: any[],
+	globalProviders: any[] = []
+): void {
+	if (visited.has(moduleClass)) return;
+
+	visiting.add(moduleClass);
+
+	const instance = new moduleClass();
+	const config = instance.moduleConfig || {};
+	const isGlobal = Reflect.getMetadata(GLOBAL_MODULE_METADATA, moduleClass) === true;
+
+	for (const c of config.controllers ?? []) {
+		if (!controllers.includes(c)) controllers.push(c);
+	}
+	for (const p of config.providers ?? []) {
+		if (!providers.includes(p)) providers.push(p);
+		if (isGlobal && !globalProviders.includes(p)) globalProviders.push(p);
+	}
+
+	for (const importRef of config.imports ?? []) {
+		const isRef = isForwardRef(importRef);
+		const ImportedClass = isRef ? importRef.forwardRef() : importRef;
+
+		if (visiting.has(ImportedClass)) {
+			if (!isRef) {
+				throw new Error(
+					`[Wilt DI] Circular module dependency detected: "${moduleClass.name}" imports "${ImportedClass.name}" ` +
+						`without forwardRef. Wrap it with forwardRef(() => ${ImportedClass.name}) ` +
+						`in "${moduleClass.name}" imports array, and do the same in "${ImportedClass.name}".`
+				);
+			}
+			continue;
+		}
+
+		collectModuleTree(ImportedClass, visiting, visited, controllers, providers, globalProviders);
+	}
+
+	visiting.delete(moduleClass);
+	visited.add(moduleClass);
+}

package/src/injector/module.factory.ts

@@ -0,0 +1,74 @@
+import { Hono } from "hono";
+import { registerControllerRoutes } from "../decorators/http/controller.decorator";
+import { GLOBAL_MODULE_METADATA } from "../decorators/modules/global.decorator";
+import { logger } from "../utils/logger.util";
+import { collectModuleTree } from "./module-compiler";
+import { resolveInstance } from "./injector";
+
+export function createModule<B extends object = Record<string, unknown>>(
+	moduleClass: any,
+	{ middlewares = [] }: { middlewares?: any[] } = {}
+): Hono<{ Bindings: B }> {
+	const router = new Hono<{ Bindings: B }>();
+
+	logger.info(`Creating module: ${moduleClass.name}`, "ModuleFactory");
+
+	middlewares.forEach((middleware) => router.use("*", middleware));
+
+	const controllers: any[] = [];
+	const providers: any[] = [];
+	const globalProviders: any[] = [];
+
+	collectModuleTree(moduleClass, new Set(), new Set(), controllers, providers, globalProviders);
+
+	logger.info(
+		`Resolved ${providers.length} providers, ${controllers.length} controllers`,
+		"ModuleFactory"
+	);
+
+	const instanceRegistry = new Map<any, any>();
+	const inProgress = new Set<any>();
+
+	// Global providers are resolved first so they're available to all modules
+	for (const ProviderClass of globalProviders) {
+		resolveInstance(ProviderClass, instanceRegistry, inProgress);
+	}
+
+	for (const ProviderClass of providers) {
+		resolveInstance(ProviderClass, instanceRegistry, inProgress);
+	}
+
+	for (const ControllerClass of controllers) {
+		try {
+			resolveInstance(ControllerClass, instanceRegistry, inProgress);
+			const controller = instanceRegistry.get(ControllerClass);
+			const prefix = (controller.constructor as any).prototype.prefix || "";
+			registerControllerRoutes(router, controller, prefix, instanceRegistry);
+			logger.debug(
+				`Registered controller: ${ControllerClass.name} at "${prefix}"`,
+				"ModuleFactory"
+			);
+		} catch (error) {
+			logger.error(
+				`Failed to create controller "${ControllerClass.name}": ${error}`,
+				"ModuleFactory"
+			);
+			throw error;
+		}
+	}
+
+	// Call onModuleInit on all instances that implement it
+	for (const instance of instanceRegistry.values()) {
+		if (typeof instance?.onModuleInit === "function") {
+			const result = instance.onModuleInit();
+			if (result instanceof Promise) {
+				result.catch((err) =>
+					logger.error(`onModuleInit failed for ${instance.constructor?.name}: ${err}`, "ModuleFactory")
+				);
+			}
+		}
+	}
+
+	logger.info(`Module "${moduleClass.name}" created successfully`, "ModuleFactory");
+	return router;
+}

package/src/interfaces/core/filter.interface.ts

@@ -0,0 +1,5 @@
+import type { ArgumentsHost } from "../../context/execution-context";
+
+export interface ExceptionFilter<T = any> {
+	catch(exception: T, host: ArgumentsHost): Response | Promise<Response> | void;
+}

package/src/interfaces/core/guard.interface.ts

@@ -0,0 +1,5 @@
+import type { ExecutionContext } from "../../context/execution-context";
+
+export interface CanActivate {
+	canActivate(context: ExecutionContext): boolean | Promise<boolean>;
+}

package/src/interfaces/core/index.ts

@@ -0,0 +1,5 @@
+export * from "./guard.interface";
+export * from "./interceptor.interface";
+export * from "./filter.interface";
+export * from "./pipe.interface";
+export * from "./lifecycle.interface";

package/src/interfaces/core/interceptor.interface.ts

@@ -0,0 +1,9 @@
+import type { ExecutionContext } from "../../context/execution-context";
+
+export interface CallHandler<T = any> {
+	handle(): Promise<T>;
+}
+
+export interface NestInterceptor<T = any, R = any> {
+	intercept(context: ExecutionContext, next: CallHandler<T>): Promise<R>;
+}

package/src/interfaces/core/lifecycle.interface.ts

@@ -0,0 +1,19 @@
+export interface OnModuleInit {
+	onModuleInit(): void | Promise<void>;
+}
+
+export interface OnModuleDestroy {
+	onModuleDestroy(): void | Promise<void>;
+}
+
+export interface OnApplicationBootstrap {
+	onApplicationBootstrap(): void | Promise<void>;
+}
+
+export interface BeforeApplicationShutdown {
+	beforeApplicationShutdown(signal?: string): void | Promise<void>;
+}
+
+export interface OnApplicationShutdown {
+	onApplicationShutdown(signal?: string): void | Promise<void>;
+}

package/src/interfaces/core/pipe.interface.ts

@@ -0,0 +1,9 @@
+export interface ArgumentMetadata {
+	type: "body" | "query" | "param" | "custom";
+	metatype?: new (...args: any[]) => any;
+	data?: string;
+}
+
+export interface PipeTransform<T = any, R = any> {
+	transform(value: T, metadata: ArgumentMetadata): R | Promise<R>;
+}

package/src/interfaces/http/index.ts

@@ -0,0 +1 @@
+export * from "./response.interface";

package/src/interfaces/http/response.interface.ts

@@ -0,0 +1,27 @@
+export type HttpStatusCode = 200 | 201 | 202 | 400 | 401 | 403 | 404 | 409 | 500;
+
+export interface BaseResponse<T = any> {
+	success: boolean;
+	data?: T;
+	message?: string;
+	timestamp: string;
+}
+
+export interface PaginatedResponse<T = any> extends BaseResponse<T[]> {
+	pagination: {
+		page: number;
+		limit: number;
+		total: number;
+		totalPages: number;
+	};
+}
+
+export interface ErrorResponse {
+	success: false;
+	error: {
+		code: string;
+		message: string;
+		stack?: string;
+	};
+	timestamp: string;
+}

package/src/interfaces/index.ts

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

package/src/interfaces/modules/index.ts

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

package/src/interfaces/modules/module.interface.ts

@@ -0,0 +1,17 @@
+export interface ForwardReference<T = any> {
+	forwardRef: () => T;
+}
+
+export interface ModuleMetadata {
+	imports?: any[];
+	controllers?: any[];
+	providers?: any[];
+	exports?: any[];
+	entities?: any[];
+}
+
+export interface RouteMetadata {
+	method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+	path: string;
+	handler: string;
+}

package/src/middleware/error-handler.middleware.ts

@@ -0,0 +1,63 @@
+import type { Context, Next } from "hono";
+import { HttpException } from "../exceptions/http-exception";
+
+function isHttpException(err: unknown): err is HttpException {
+	return (
+		err instanceof HttpException ||
+		(err instanceof Error &&
+			typeof (err as any).getStatus === "function" &&
+			typeof (err as any).getResponse === "function")
+	);
+}
+
+function isZodError(err: unknown): err is Error & { issues: Array<{ path: (string | number)[]; message: string; code: string }> } {
+	return (
+		err instanceof Error &&
+		(err as any).name === "ZodError" &&
+		Array.isArray((err as any).issues)
+	);
+}
+
+export async function errorHandler(c: Context, next: Next) {
+	try {
+		await next();
+	} catch (error) {
+		if (isHttpException(error)) {
+			const response = error.getResponse();
+			const body =
+				typeof response === "string"
+					? { success: false, error: { code: error.name, message: response }, timestamp: new Date().toISOString() }
+					: { success: false, ...response, timestamp: new Date().toISOString() };
+			return c.json(body, error.getStatus() as any);
+		}
+
+		if (isZodError(error)) {
+			const details = error.issues.map((i) => ({
+				field: i.path.join("."),
+				message: i.message,
+				code: i.code,
+			}));
+			return c.json(
+				{
+					success: false,
+					error: { code: "VALIDATION_ERROR", message: "Validation failed", details },
+					timestamp: new Date().toISOString(),
+				},
+				400,
+			);
+		}
+
+		console.error("Unhandled error:", error);
+		return c.json(
+			{
+				success: false,
+				error: {
+					code: "INTERNAL_ERROR",
+					message: error instanceof Error ? error.message : "Internal server error",
+				},
+				timestamp: new Date().toISOString(),
+			},
+			500
+		);
+	}
+}

package/src/middleware/index.ts

@@ -0,0 +1,2 @@
+export { errorHandler } from "./error-handler.middleware";
+export { requestLogger } from "./request-logger.middleware";

package/src/middleware/request-logger.middleware.ts

@@ -0,0 +1,17 @@
+import type { Context, Next } from "hono";
+import { logger } from "../utils/logger.util";
+
+export async function requestLogger(c: Context, next: Next) {
+	const start = Date.now();
+	const method = c.req.method;
+	const path = c.req.path;
+	const userAgent = c.req.header("User-Agent");
+
+	await next();
+
+	const end = Date.now();
+	const duration = end - start;
+	const status = c.res.status;
+
+	logger.http(method, path, status, duration, userAgent);
+}

package/src/pipes/index.ts

@@ -0,0 +1,3 @@
+export * from "./validate.pipe";
+export * from "./zod-validate.pipe";
+export * from "./zod-query.pipe";

package/src/pipes/validate.pipe.ts

@@ -0,0 +1,79 @@
+import type { Context } from "hono";
+
+export interface ValidationRule {
+	field: string;
+	required?: boolean;
+	type?: "string" | "number" | "boolean" | "object" | "array";
+	minLength?: number;
+	maxLength?: number;
+	pattern?: RegExp;
+	custom?: (value: any) => boolean;
+}
+
+export function Validate(rules: ValidationRule[]) {
+	return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+		const originalMethod = descriptor.value;
+
+		descriptor.value = async function (...args: any[]) {
+			const c: Context = args.find((a: any) => a != null && typeof a.json === "function" && a.req != null) ?? args[0];
+			const body = await c.req.json().catch(() => ({}));
+			const errors: string[] = [];
+
+			for (const rule of rules) {
+				const value = body[rule.field];
+
+				if (rule.required && (value === undefined || value === null || value === "")) {
+					errors.push(`${rule.field} is required`);
+					continue;
+				}
+
+				if (value === undefined || value === null) {
+					continue;
+				}
+
+				if (rule.type) {
+					const actualType = Array.isArray(value) ? "array" : typeof value;
+					if (actualType !== rule.type) {
+						errors.push(`${rule.field} must be of type ${rule.type}`);
+					}
+				}
+
+				if (rule.type === "string" || typeof value === "string") {
+					if (rule.minLength && value.length < rule.minLength) {
+						errors.push(`${rule.field} must be at least ${rule.minLength} characters long`);
+					}
+					if (rule.maxLength && value.length > rule.maxLength) {
+						errors.push(`${rule.field} must be at most ${rule.maxLength} characters long`);
+					}
+				}
+
+				if (rule.pattern && typeof value === "string" && !rule.pattern.test(value)) {
+					errors.push(`${rule.field} format is invalid`);
+				}
+
+				if (rule.custom && !rule.custom(value)) {
+					errors.push(`${rule.field} validation failed`);
+				}
+			}
+
+			if (errors.length > 0) {
+				return c.json(
+					{
+						success: false,
+						error: {
+							code: "VALIDATION_ERROR",
+							message: "Validation failed",
+							details: errors,
+						},
+						timestamp: new Date().toISOString(),
+					},
+					400,
+				);
+			}
+
+			return originalMethod.call(this, ...args);
+		};
+
+		return descriptor;
+	};
+}

package/src/pipes/zod-query.pipe.ts

@@ -0,0 +1,42 @@
+import type { Context } from "hono";
+import { z } from "zod";
+
+export function QueryValidate(schema: z.ZodSchema) {
+	return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+		const originalMethod = descriptor.value;
+
+		descriptor.value = async function (...args: any[]) {
+			const c: Context = args.find((a: any) => a != null && typeof a.json === "function" && a.req != null) ?? args[0];
+			try {
+				const queryParams = c.req.query();
+				const validatedData = schema.parse(queryParams);
+				c.set("validatedQuery", validatedData);
+				return originalMethod.call(this, ...args);
+			} catch (error) {
+				if (error instanceof z.ZodError) {
+					const errors = error.issues.map((err: z.ZodIssue) => ({
+						field: err.path.join("."),
+						message: err.message,
+						code: err.code,
+					}));
+					return c.json(
+						{
+							success: false,
+							error: {
+								code: "VALIDATION_ERROR",
+								message: "Query validation failed",
+								details: errors,
+							},
+							message: errors[0].message ?? "Validation failed",
+							timestamp: new Date().toISOString(),
+						},
+						400,
+					);
+				}
+				throw error;
+			}
+		};
+
+		return descriptor;
+	};
+}

package/src/pipes/zod-validate.pipe.ts

@@ -0,0 +1,49 @@
+import type { Context } from "hono";
+import { z } from "zod";
+
+export function ZodValidate(schema: z.ZodSchema) {
+	return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+		const originalMethod = descriptor.value;
+
+		descriptor.value = async function (...args: any[]) {
+			const c: Context = args.find((a: any) => a != null && typeof a.json === "function" && a.req != null) ?? args[0];
+			try {
+				const contentType = c.req.header("content-type") || "";
+				let input: any = {};
+
+				if (contentType.includes("multipart/form-data")) {
+					const formData = await c.req.formData();
+					formData.forEach((val, key) => {
+						input[key] = val;
+					});
+				} else {
+					input = await c.req.json().catch(() => ({}));
+				}
+
+				const validatedData = schema.parse(input);
+				c.set("validatedData", validatedData);
+				return originalMethod.call(this, ...args);
+			} catch (error) {
+				if (error instanceof z.ZodError) {
+					const errors = error.issues.map((err) => ({
+						field: err.path.join("."),
+						message: err.message,
+						code: err.code,
+					}));
+					return c.json(
+						{
+							success: false,
+							error: { code: "VALIDATION_ERROR", message: "Validation failed", details: errors },
+							message: errors[0].message ?? "Validation failed",
+							timestamp: new Date().toISOString(),
+						},
+						400,
+					);
+				}
+				throw error;
+			}
+		};
+
+		return descriptor;
+	};
+}

package/src/services/index.ts

@@ -0,0 +1 @@
+export * from "./reflector.service";

package/src/services/reflector.service.ts

@@ -0,0 +1,24 @@
+import { Injectable } from "../decorators/core/injectable.decorator";
+
+@Injectable()
+export class Reflector {
+	get<T = any>(metadataKey: string, target: Function): T {
+		return Reflect.getMetadata(metadataKey, target) as T;
+	}
+
+	getAllAndOverride<T = any>(metadataKey: string, targets: Function[]): T {
+		for (const target of targets) {
+			const value = Reflect.getMetadata(metadataKey, target);
+			if (value !== undefined) return value as T;
+		}
+		return undefined as unknown as T;
+	}
+
+	getAllAndMerge<T extends any[] = any[]>(metadataKey: string, targets: Function[]): T {
+		return targets.reduce<any[]>((acc, target) => {
+			const value = Reflect.getMetadata(metadataKey, target);
+			if (Array.isArray(value)) return [...acc, ...value];
+			return acc;
+		}, []) as T;
+	}
+}

package/src/utils/apply-decorators.util.ts

@@ -0,0 +1,17 @@
+export function applyDecorators(
+	...decorators: (ClassDecorator | MethodDecorator | PropertyDecorator)[]
+): (...args: any[]) => any {
+	return (target: any, key?: any, descriptor?: any): any => {
+		for (const decorator of decorators.reverse()) {
+			const result = (decorator as any)(target, key, descriptor);
+			if (result !== undefined) {
+				if (descriptor !== undefined) {
+					descriptor = result as PropertyDescriptor;
+				} else {
+					target = result;
+				}
+			}
+		}
+		return descriptor ?? target;
+	};
+}

package/src/utils/forward-ref.util.ts

@@ -0,0 +1,14 @@
+import type { ForwardReference } from "../interfaces/modules/module.interface";
+
+export function forwardRef<T = any>(fn: () => T): ForwardReference<T> {
+	return { forwardRef: fn };
+}
+
+export function isForwardRef(val: any): val is ForwardReference {
+	return (
+		val !== null &&
+		val !== undefined &&
+		typeof val === "object" &&
+		typeof val.forwardRef === "function"
+	);
+}