@mini2/core 1.0.2 → 1.0.5

package/middlewares/validation.middleware.ts

@@ -1,76 +0,0 @@
-import { plainToInstance } from 'class-transformer';
-import { validate, ValidationError } from 'class-validator';
-import type { RequestHandler, Request, Response, NextFunction } from 'express';
-import type { IValidationError } from '../expections/http.expection';
-import HttpException from '../expections/http.expection';
-
-const validationMiddleware = <T extends object>(
-	type: new () => T,
-	value: 'body' | 'query' | 'params',
-	skipMissingProperties = false,
-	whitelist = true,
-	forbidNonWhitelisted = true
-): RequestHandler => {
-	return (req: Request, _res: Response, next: NextFunction) => {
-		// Query parametrelerinde boolean değerleri düzgün işle
-		if (value === 'query' && req.query) {
-			Object.keys(req.query).forEach((key) => {
-				if (req.query[key] === 'true') req.query[key] = true as any;
-				if (req.query[key] === 'false') req.query[key] = false as any;
-			});
-		}
-
-		// 🔽 Eğer dosya alanları varsa, req.body'ye dahil et
-		if (value === 'body' && req.files) {
-			const files = req.files as Record<string, Express.Multer.File[]>;
-			for (const field in files) {
-				if (Array.isArray(files[field]) && files[field].length > 0) {
-					req.body[field] = files[field][0]; // sadece ilk dosyayı al
-				}
-			}
-		}
-
-		const data = plainToInstance(type, req[value], {
-			enableImplicitConversion: true, // Otomatik tip dönüşümü için
-			exposeDefaultValues: true,
-		});
-
-		validate(data as object, {
-			skipMissingProperties,
-			whitelist,
-			forbidNonWhitelisted,
-		}).then((errors: ValidationError[]) => {
-			if (errors.length > 0) {
-				const messages: IValidationError[] = errors.map(
-					(error: ValidationError) => {
-						const error1: IValidationError = {
-							field: error.property,
-							errors: [],
-						};
-						for (const key of Object.keys(error?.constraints || {})) {
-							if (error.constraints?.[key]) {
-								error1.errors.push(error.constraints[key]);
-							}
-						}
-						return error1;
-					}
-				);
-				next(
-					new HttpException(
-						{
-							errorId: 1,
-							message: 'Validation error',
-							validationErrors: messages,
-						},
-						400
-					)
-				);
-			} else {
-				req[value] = data as any;
-				next();
-			}
-		});
-	};
-};
-
-export default validationMiddleware;

package/response-builder.ts

@@ -1,61 +0,0 @@
-import type { Response } from 'express';
-
-export interface IResponseBuilder<T = any> {
-	status: number;
-	data: T;
-	headers: Record<string, string>;
-	isFile: boolean;
-
-	ok(data: T): IResponseBuilder<T>;
-	created(data: T): IResponseBuilder<T>;
-	setHeader(key: string, value: string): IResponseBuilder<T>;
-	setHeaders(headers: Record<string, string>): IResponseBuilder<T>;
-	asFile(): IResponseBuilder<T>;
-	build(res: Response): void;
-}
-
-export class ResponseBuilder<T> implements IResponseBuilder<T> {
-	public status: number = 200;
-	public data!: T;
-	public headers: Record<string, string> = {};
-	public isFile: boolean = false;
-
-	ok(data: T): ResponseBuilder<T> {
-		this.status = 200;
-		this.data = data;
-		return this;
-	}
-
-	created(data: T): ResponseBuilder<T> {
-		this.status = 201;
-		this.data = data;
-		return this;
-	}
-
-	setHeader(key: string, value: string): ResponseBuilder<T> {
-		this.headers[key] = value;
-		return this;
-	}
-
-	setHeaders(headers: Record<string, string>): ResponseBuilder<T> {
-		this.headers = { ...this.headers, ...headers };
-		return this;
-	}
-
-	asFile(): ResponseBuilder<T> {
-		this.isFile = true;
-		return this;
-	}
-
-	build(res: Response): void {
-		Object.entries(this.headers).forEach(([key, value]) => {
-			res.setHeader(key, value);
-		});
-
-		if (this.isFile && this.data) {
-			res.status(this.status).send(this.data);
-		} else {
-			res.status(this.status).json(this.data);
-		}
-	}
-}

package/rest.ts

@@ -1,254 +0,0 @@
-import 'reflect-metadata';
-import express, { type Express } from 'express';
-import type {
-	Request,
-	Response,
-	NextFunction,
-	IRouter,
-	RequestHandler,
-} from 'express';
-import { arrayUnify } from './utils/array-unify';
-import { IResponseBuilder } from './response-builder';
-import validationMiddleware from './middlewares/validation.middleware';
-import { authenticatedMiddleware } from './middlewares/authenticated.middleware';
-import { authorizedMiddleware } from './middlewares/authorized.middleware';
-
-export type Method = 'get' | 'post' | 'put' | 'delete' | 'patch';
-export const keyOfPath = Symbol('path');
-export const keyOfRouteOptions = Symbol('routeOptions');
-export const keyOfReq = Symbol('req');
-export const keyOfRes = Symbol('res');
-export const keyOfNext = Symbol('next');
-
-// Controller method signature type'ı
-export type ControllerMethodSignature = (
-	...args: (Request | Response | NextFunction)[]
-) => IResponseBuilder | Promise<IResponseBuilder>;
-export type IValidation = {
-	body?: any;
-	params?: any;
-	query?: any;
-};
-export interface RouteOptions {
-	method?: Method;
-	path?: string;
-	validations?: IValidation[];
-	permissions?: string[];
-	authenticated?: boolean;
-	otherHttpMiddlewares?: RequestHandler[];
-}
-
-export function controller(path: string) {
-	return function <T extends { new (...args: any[]): {} }>(constructor: T) {
-		Reflect.defineMetadata(keyOfPath, path, constructor);
-		return constructor;
-	};
-}
-export function httpMethod(newOptions: RouteOptions) {
-	return function (
-		target: any,
-		propertyKey: string,
-		_descriptor: PropertyDescriptor
-	) {
-		const existingOptions =
-			Reflect.getMetadata(keyOfRouteOptions, target, propertyKey) || {};
-		const method = newOptions.method || existingOptions.method;
-		const path = newOptions.path || existingOptions.path;
-		const validations = arrayUnify(
-			(newOptions.validations || []).concat(existingOptions.validations || [])
-		);
-		const permissions = arrayUnify(
-			(newOptions.permissions || []).concat(existingOptions.permissions || [])
-		);
-		const authenticated =
-			newOptions.authenticated || existingOptions.authenticated;
-		const otherHttpMiddlewares = arrayUnify(
-			(newOptions.otherHttpMiddlewares || []).concat(
-				existingOptions.otherHttpMiddlewares || []
-			)
-		);
-		const mergedOptions = {
-			method,
-			path,
-			validations,
-			permissions,
-			authenticated,
-			otherHttpMiddlewares,
-		};
-
-		Reflect.defineMetadata(keyOfRouteOptions, mergedOptions, target, propertyKey);
-	};
-}
-export function get(path: string) {
-	return httpMethod({ path, method: 'get' });
-}
-export function post(path: string) {
-	return httpMethod({ path, method: 'post' });
-}
-export function put(path: string) {
-	return httpMethod({ path, method: 'put' });
-}
-export function del(path: string) {
-	return httpMethod({ path, method: 'delete' });
-}
-export function patch(path: string) {
-	return httpMethod({ path, method: 'patch' });
-}
-export function validate(options: IValidation | IValidation[]) {
-	return httpMethod({
-		validations: Array.isArray(options) ? options : [options],
-	});
-}
-export function authenticated(value: boolean = true) {
-	return httpMethod({ authenticated: value });
-}
-export function authorized(value: string | string[]) {
-	return httpMethod({
-		permissions: Array.isArray(value) ? value : [value],
-	});
-}
-export function middleware(middlewares: RequestHandler) {
-	return httpMethod({ otherHttpMiddlewares: [middlewares] });
-}
-
-// Param decorator'ları
-export function req() {
-	return function (target: any, propertyKey: string, parameterIndex: number) {
-		Reflect.defineMetadata(keyOfReq, parameterIndex, target, propertyKey);
-	};
-}
-
-export function res() {
-	return function (target: any, propertyKey: string, parameterIndex: number) {
-		Reflect.defineMetadata(keyOfRes, parameterIndex, target, propertyKey);
-	};
-}
-export function next() {
-	return function (target: any, propertyKey: string, parameterIndex: number) {
-		Reflect.defineMetadata(keyOfNext, parameterIndex, target, propertyKey);
-	};
-}
-export function buildRouterFromController(controllerClass: any): IRouter {
-	const path = Reflect.getMetadata(keyOfPath, controllerClass.constructor);
-	if (!path) {
-		throw new Error('Controller class must have a path property');
-	}
-	const allProperties = Object.getOwnPropertyNames(
-		Object.getPrototypeOf(controllerClass)
-	);
-	const router = express.Router();
-	for (const property of allProperties) {
-		const routeOptions: RouteOptions = Reflect.getMetadata(
-			keyOfRouteOptions,
-			controllerClass,
-			property
-		);
-		if (!routeOptions) {
-			continue;
-		}
-		if (!routeOptions.path) {
-			throw new Error('Route path is required');
-		}
-		if (!routeOptions.method) {
-			throw new Error('Route method is required');
-		}
-
-		const validations = routeOptions.validations;
-		const permissions = routeOptions.permissions;
-		const authenticated = routeOptions.authenticated;
-		const otherHttpMiddlewares = routeOptions.otherHttpMiddlewares;
-		const handler = controllerClass[property];
-		const validationMiddlewares = [];
-		if (validations) {
-			for (const validation of validations) {
-				if (validation.body) {
-					validationMiddlewares.push(validationMiddleware(validation.body, 'body'));
-				}
-				if (validation.params) {
-					validationMiddlewares.push(
-						validationMiddleware(validation.params, 'params')
-					);
-				}
-				if (validation.query) {
-					validationMiddlewares.push(
-						validationMiddleware(validation.query, 'query')
-					);
-				}
-			}
-		}
-		const middlewares: RequestHandler[] = [];
-		if (authenticated) {
-			middlewares.push(authenticatedMiddleware as unknown as RequestHandler);
-		}
-		if (permissions) {
-			middlewares.push(
-				authorizedMiddleware(permissions) as unknown as RequestHandler
-			);
-		}
-		if (otherHttpMiddlewares) {
-			middlewares.push(...otherHttpMiddlewares);
-		}
-		if (validationMiddlewares) {
-			middlewares.push(...validationMiddlewares);
-		}
-
-		const method = routeOptions.method;
-		const routePath = routeOptions.path;
-		const reqIndex = Reflect.getMetadata(keyOfReq, controllerClass, property);
-		const resIndex = Reflect.getMetadata(keyOfRes, controllerClass, property);
-		const nextIndex = Reflect.getMetadata(keyOfNext, controllerClass, property);
-		const argsNotSorted = [
-			{ name: 'req', index: reqIndex },
-			{ name: 'res', index: resIndex },
-			{ name: 'next', index: nextIndex },
-		];
-		const args = [...argsNotSorted];
-		const argsSorted = args.sort((a, b) => a.index - b.index);
-		const handlerMiddleware = async (
-			req: Request,
-			res: Response,
-			next: NextFunction
-		) => {
-			try {
-				const realArgs = [];
-				for (const arg of argsSorted) {
-					if (arg.name === 'req') {
-						realArgs.push(req);
-					} else if (arg.name === 'res') {
-						realArgs.push(res);
-					} else if (arg.name === 'next') {
-						realArgs.push(next);
-					}
-				}
-				const result = await handler(...realArgs);
-
-				// ResponseBuilder'ı handle et
-				if (result && typeof result.build === 'function') {
-					result.build(res);
-				} else {
-					res.json(result);
-				}
-			} catch (error) {
-				next(error);
-			}
-		};
-		router[method](
-			routePath,
-			...middlewares,
-			handlerMiddleware as RequestHandler
-		);
-	}
-	return router;
-}
-export function buildApp(app: Express, controllers: any[]) {
-	for (const controller of controllers) {
-		const router = buildRouterFromController(controller);
-		const controllerPath = Reflect.getMetadata(keyOfPath, controller.constructor);
-		if (controllerPath) {
-			app.use(controllerPath, router);
-		} else {
-			app.use(router);
-		}
-	}
-	return app;
-}

package/swagger.ts

@@ -1,265 +0,0 @@
-import 'reflect-metadata';
-import swaggerUi from 'swagger-ui-express';
-import { Express } from 'express';
-import { keyOfPath, keyOfRouteOptions, RouteOptions } from './rest';
-import { validationMetadatasToSchemas } from 'class-validator-jsonschema';
-
-export interface SwaggerOptions {
-	title?: string;
-	description?: string;
-	version?: string;
-	servers?: { url: string; description?: string }[];
-	docsPath?: string;
-	jsonPath?: string;
-	components?: any;
-}
-
-export class SwaggerIntegration {
-	private swaggerSpec: any;
-	private options: SwaggerOptions;
-
-	constructor(options: SwaggerOptions = {}) {
-		this.options = {
-			title: 'Mini Framework API',
-			description: 'API documentation for Mini Framework',
-			version: '1.0.0',
-			servers: [
-				{ url: 'http://localhost:3000', description: 'Development server' },
-			],
-			docsPath: '/api-docs',
-			jsonPath: '/api-docs.json',
-			...options,
-		};
-	}
-
-	public generateSwaggerSpec(controllers: any[]) {
-		const paths: any = {};
-		const components: any = {
-			securitySchemes: {
-				bearerAuth: {
-					type: 'http',
-					scheme: 'bearer',
-					bearerFormat: 'JWT',
-				},
-			},
-			schemas: validationMetadatasToSchemas(),
-		};
-
-		controllers.forEach((controller, index) => {
-			const controllerPath = Reflect.getMetadata(
-				keyOfPath,
-				controller.constructor
-			);
-			if (!controllerPath) {
-				console.log(`❌ No path metadata found for ${controller.constructor.name}`);
-				return;
-			}
-
-			const allProperties = Object.getOwnPropertyNames(
-				Object.getPrototypeOf(controller)
-			);
-
-			allProperties.forEach((property) => {
-				const routeOptions: RouteOptions = Reflect.getMetadata(
-					keyOfRouteOptions,
-					controller,
-					property
-				);
-
-				if (!routeOptions || !routeOptions.path || !routeOptions.method) {
-					if (property !== 'constructor') {
-						console.log(`⚠️ Skipping ${property} - no valid route options`);
-					}
-					return;
-				}
-
-				const fullPath = controllerPath + routeOptions.path;
-				const method = routeOptions.method.toLowerCase();
-				if (!paths[fullPath]) {
-					paths[fullPath] = {};
-				}
-
-				// Generate OpenAPI operation
-				const operation: any = {
-					summary: this.generateSummary(method, fullPath),
-					description: this.generateDescription(method, fullPath),
-					tags: [this.extractControllerTag(controllerPath)],
-					responses: {
-						'200': {
-							description: 'Success',
-							content: {
-								'application/json': {
-									schema: {
-										type: 'object',
-									},
-								},
-							},
-						},
-					},
-				};
-
-				// Add parameters from path
-				const pathParams = this.extractPathParameters(routeOptions.path);
-				if (pathParams.length > 0) {
-					operation.parameters = pathParams.map((param) => ({
-						name: param,
-						in: 'path',
-						required: true,
-						schema: {
-							type: 'string',
-						},
-					}));
-				}
-
-				// Add request body for POST/PUT/PATCH
-				if (['post', 'put', 'patch'].includes(method) && routeOptions.validations) {
-					const bodyValidation = routeOptions.validations?.find((v) => v.body);
-					if (bodyValidation) {
-						operation.requestBody = {
-							required: true,
-							content: {
-								'application/json': {
-									schema: this.generateSchemaFromValidation(bodyValidation.body),
-								},
-							},
-						};
-					}
-				}
-
-				// Add security if authenticated
-				if (routeOptions.authenticated) {
-					operation.security = [{ bearerAuth: [] }];
-				}
-
-				// Add error responses
-				if (routeOptions.authenticated) {
-					operation.responses['401'] = {
-						description: 'Unauthorized',
-					};
-				}
-
-				if (routeOptions.permissions && routeOptions.permissions.length > 0) {
-					operation.responses['403'] = {
-						description: 'Forbidden',
-					};
-				}
-
-				operation.responses['400'] = {
-					description: 'Bad Request',
-				};
-
-				paths[fullPath][method] = operation;
-			});
-		});
-		this.swaggerSpec = {
-			openapi: '3.0.0',
-			info: {
-				title: this.options.title!,
-				description: this.options.description!,
-				version: this.options.version!,
-				contact: {
-					name: 'API Support',
-					email: 'support@example.com',
-				},
-			},
-			servers: this.options.servers,
-			paths,
-			components,
-		};
-	}
-
-	private generateSummary(method: string, path: string): string {
-		const action = method.toUpperCase();
-		const resource = this.extractResourceName(path);
-
-		const actionMap: { [key: string]: string } = {
-			GET: path.includes('/:') ? `Get ${resource} by ID` : `Get all ${resource}`,
-			POST: `Create ${resource}`,
-			PUT: `Update ${resource}`,
-			PATCH: `Partially update ${resource}`,
-			DELETE: `Delete ${resource}`,
-		};
-
-		return actionMap[action] || `${action} ${resource}`;
-	}
-
-	private generateDescription(method: string, path: string): string {
-		const action = method.toLowerCase();
-		const resource = this.extractResourceName(path);
-
-		const descriptions: { [key: string]: string } = {
-			get: path.includes('/:')
-				? `Retrieve a specific ${resource} by its ID`
-				: `Retrieve all ${resource} records`,
-			post: `Create a new ${resource} record`,
-			put: `Update an existing ${resource} record`,
-			patch: `Partially update an existing ${resource} record`,
-			delete: `Delete a ${resource} record`,
-		};
-
-		return descriptions[action] || `${action} operation on ${resource}`;
-	}
-
-	private extractControllerTag(controllerPath: string): string {
-		const segments = controllerPath.split('/').filter(Boolean);
-		const lastSegment = segments[segments.length - 1];
-		return lastSegment.charAt(0).toUpperCase() + lastSegment.slice(1);
-	}
-
-	private extractResourceName(path: string): string {
-		const segments = path.split('/').filter(Boolean);
-		let resource = segments[segments.length - 1];
-
-		// Remove path parameters (e.g., :id)
-		if (resource.startsWith(':')) {
-			resource = segments[segments.length - 2] || 'Resource';
-		}
-
-		return resource.charAt(0).toUpperCase() + resource.slice(1);
-	}
-
-	private extractPathParameters(path: string): string[] {
-		const matches = path.match(/:([a-zA-Z_][a-zA-Z0-9_]*)/g);
-		return matches ? matches.map((match) => match.substring(1)) : [];
-	}
-
-	private generateSchemaFromValidation(validationClass: any): any {
-		const className = validationClass.name;
-		return { $ref: `#/components/schemas/${className}` };
-	}
-
-	public setupSwagger(app: Express) {
-		// Swagger UI middleware
-		app.use(
-			this.options.docsPath!,
-			swaggerUi.serve,
-			swaggerUi.setup(this.swaggerSpec, {
-				explorer: true,
-				customCss: '.swagger-ui .topbar { display: none }',
-				customSiteTitle: this.options.title,
-				swaggerOptions: {
-					docExpansion: 'list',
-					filter: true,
-					showRequestHeaders: true,
-					tryItOutEnabled: true,
-					persistAuthorization: true,
-				},
-			})
-		);
-
-		// JSON endpoint for OpenAPI spec
-		app.get(this.options.jsonPath!, (req, res) => {
-			res.setHeader('Content-Type', 'application/json');
-			res.send(this.swaggerSpec);
-		});
-
-		console.log(`📚 Swagger UI available at: ${this.options.docsPath}`);
-		console.log(`📄 OpenAPI JSON spec available at: ${this.options.jsonPath}`);
-	}
-
-	public getSwaggerSpec() {
-		return this.swaggerSpec;
-	}
-}
-
-export default SwaggerIntegration;

package/types.ts

@@ -1,3 +0,0 @@
-export const MINI_TYPES = {
-	IController: Symbol.for('IController'),
-};

package/utils/array-unify.ts

@@ -1,4 +0,0 @@
-export function arrayUnify<T>(array: T[]) {
-	const unified = [...new Set([...array])];
-	return unified;
-}

package/utils/math.ts

@@ -1,3 +0,0 @@
-export function sum(a: number, b: number): number {
-	return a + b;
-}