@mini2/core 1.0.1 → 1.0.5

package/__tests__/controller.test.ts

@@ -1,349 +0,0 @@
-import {
-	IsEmail,
-	IsNotEmpty,
-	validate as classValidate,
-} from 'class-validator';
-import {
-	authorized,
-	middleware,
-	authenticated,
-	controller,
-	get,
-	httpMethod,
-	validate,
-	req,
-	res,
-	buildRouterFromController,
-} from '../rest';
-import { IResponseBuilder, ResponseBuilder } from '../response-builder';
-
-// Simple test class without problematic decorators
-class TestClass {
-	testMethod(req: any, res: any): IResponseBuilder {
-		return new ResponseBuilder().ok('test');
-	}
-
-	anotherMethod(): IResponseBuilder {
-		return new ResponseBuilder().created('created');
-	}
-}
-
-// Validation test class with decorators (manual validation for testing)
-class UserValidation {
-	email!: string;
-	username!: string;
-	password!: string;
-}
-
-// Class with actual decorators for testing (simple approach)
-class UserWithDecorators {
-	email!: string;
-	username!: string;
-	password!: string;
-
-	constructor(email: string, username: string, password: string) {
-		this.email = email;
-		this.username = username;
-		this.password = password;
-	}
-}
-
-describe('REST Framework Components', () => {
-	let testClass: TestClass;
-
-	beforeEach(() => {
-		testClass = new TestClass();
-	});
-
-	test('should create test class instance', () => {
-		expect(testClass).toBeDefined();
-		expect(testClass).toBeInstanceOf(TestClass);
-	});
-
-	test('should have test methods', () => {
-		expect(typeof testClass.testMethod).toBe('function');
-		expect(typeof testClass.anotherMethod).toBe('function');
-	});
-
-	test('decorators should be defined and importable', () => {
-		expect(controller).toBeDefined();
-		expect(get).toBeDefined();
-		expect(httpMethod).toBeDefined();
-		expect(validate).toBeDefined();
-		expect(authenticated).toBeDefined();
-		expect(authorized).toBeDefined();
-		expect(middleware).toBeDefined();
-		expect(req).toBeDefined();
-		expect(res).toBeDefined();
-		expect(buildRouterFromController).toBeDefined();
-	});
-
-	test('ResponseBuilder should work correctly', () => {
-		const okResponse = new ResponseBuilder().ok('success');
-		expect(okResponse).toBeDefined();
-		expect(okResponse).toBeInstanceOf(ResponseBuilder);
-
-		const createdResponse = new ResponseBuilder().created('created');
-		expect(createdResponse).toBeDefined();
-		expect(createdResponse).toBeInstanceOf(ResponseBuilder);
-	});
-
-	test('test class methods should return ResponseBuilder', () => {
-		const result1 = testClass.testMethod({}, {});
-		expect(result1).toBeInstanceOf(ResponseBuilder);
-
-		const result2 = testClass.anotherMethod();
-		expect(result2).toBeInstanceOf(ResponseBuilder);
-	});
-
-	test('buildRouterFromController should be callable', () => {
-		// Test that the function exists and is callable
-		expect(typeof buildRouterFromController).toBe('function');
-
-		// Don't actually call it with decorators to avoid TypeScript errors
-		// Just verify it's a function
-	});
-});
-
-describe('Validation Tests', () => {
-	test('should validate valid email', async () => {
-		const user = new UserValidation();
-		user.email = 'test@example.com';
-		user.username = 'testuser';
-		user.password = 'password123';
-
-		// Manual validation check
-		const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-		expect(emailRegex.test(user.email)).toBe(true);
-	});
-
-	test('should reject invalid email', async () => {
-		const user = new UserValidation();
-		user.email = 'invalid-email';
-		user.username = 'testuser';
-		user.password = 'password123';
-
-		// Manual validation check
-		const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-		expect(emailRegex.test(user.email)).toBe(false);
-	});
-
-	test('should validate non-empty username', () => {
-		const user = new UserValidation();
-		user.email = 'test@example.com';
-		user.username = 'testuser';
-		user.password = 'password123';
-
-		expect(user.username).toBeDefined();
-		expect(user.username.trim()).not.toBe('');
-		expect(user.username.length).toBeGreaterThan(0);
-	});
-
-	test('should reject empty username', () => {
-		const user = new UserValidation();
-		user.email = 'test@example.com';
-		user.username = '';
-		user.password = 'password123';
-
-		expect(user.username.trim()).toBe('');
-		expect(user.username.length).toBe(0);
-	});
-
-	test('should validate password requirements', () => {
-		const user = new UserValidation();
-		user.email = 'test@example.com';
-		user.username = 'testuser';
-		user.password = 'password123';
-
-		// Basic password validation
-		expect(user.password).toBeDefined();
-		expect(user.password.length).toBeGreaterThanOrEqual(6);
-	});
-
-	test('should reject weak password', () => {
-		const user = new UserValidation();
-		user.email = 'test@example.com';
-		user.username = 'testuser';
-		user.password = '123';
-
-		// Weak password check
-		expect(user.password.length).toBeLessThan(6);
-	});
-
-	test('validation decorators should be importable', () => {
-		expect(IsEmail).toBeDefined();
-		expect(IsNotEmpty).toBeDefined();
-		expect(typeof IsEmail).toBe('function');
-		expect(typeof IsNotEmpty).toBe('function');
-	});
-
-	test('should validate multiple fields together', () => {
-		const validUser = new UserValidation();
-		validUser.email = 'user@example.com';
-		validUser.username = 'validuser';
-		validUser.password = 'securepass123';
-
-		// Validate all fields
-		const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-		const isValidEmail = emailRegex.test(validUser.email);
-		const isValidUsername = validUser.username.trim().length > 0;
-		const isValidPassword = validUser.password.length >= 6;
-
-		expect(isValidEmail).toBe(true);
-		expect(isValidUsername).toBe(true);
-		expect(isValidPassword).toBe(true);
-	});
-
-	test('should handle validation edge cases', () => {
-		const user = new UserValidation();
-
-		// Test edge cases
-		user.email = 'a@b.co'; // minimum valid email
-		user.username = 'a'; // minimum username
-		user.password = '123456'; // minimum password
-
-		const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-		expect(emailRegex.test(user.email)).toBe(true);
-		expect(user.username.length).toBeGreaterThan(0);
-		expect(user.password.length).toBeGreaterThanOrEqual(6);
-	});
-
-	test('should use class-validator with plain objects', async () => {
-		// Test class-validator functionality without decorators on class
-		const plainObject = {
-			email: 'test@example.com',
-			username: 'testuser',
-			password: 'password123',
-		};
-
-		// We can test the validation logic directly
-		expect(plainObject.email).toMatch(/^[^\s@]+@[^\s@]+\.[^\s@]+$/);
-		expect(plainObject.username).toBeTruthy();
-		expect(plainObject.password).toHaveLength(11);
-	});
-
-	test('should validate user with constructor', () => {
-		const validUser = new UserWithDecorators(
-			'user@example.com',
-			'validuser',
-			'securepass123'
-		);
-
-		expect(validUser.email).toBe('user@example.com');
-		expect(validUser.username).toBe('validuser');
-		expect(validUser.password).toBe('securepass123');
-
-		// Validation logic
-		const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-		expect(emailRegex.test(validUser.email)).toBe(true);
-		expect(validUser.username.trim().length).toBeGreaterThan(0);
-		expect(validUser.password.length).toBeGreaterThanOrEqual(6);
-	});
-
-	test('should test validation helper functions', () => {
-		// Helper validation functions
-		const isValidEmail = (email: string) =>
-			/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
-		const isNotEmpty = (value: string) =>
-			Boolean(value && value.trim().length > 0);
-		const isMinLength = (value: string, min: number) =>
-			Boolean(value && value.length >= min);
-
-		// Test valid inputs
-		expect(isValidEmail('test@example.com')).toBe(true);
-		expect(isNotEmpty('testuser')).toBe(true);
-		expect(isMinLength('password123', 6)).toBe(true);
-
-		// Test invalid inputs
-		expect(isValidEmail('invalid-email')).toBe(false);
-		expect(isNotEmpty('')).toBe(false);
-		expect(isMinLength('123', 6)).toBe(false);
-	});
-
-	test('should validate complex email patterns', () => {
-		const validEmails = [
-			'user@example.com',
-			'test.email@domain.co.uk',
-			'user+tag@example.org',
-			'user_name@example-domain.com',
-		];
-
-		const invalidEmails = [
-			'invalid-email',
-			'@example.com',
-			'user@',
-			'user.example.com',
-			'user@.com',
-			'user@com',
-			'',
-		];
-
-		const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-
-		validEmails.forEach((email) => {
-			expect(emailRegex.test(email)).toBe(true);
-		});
-
-		invalidEmails.forEach((email) => {
-			expect(emailRegex.test(email)).toBe(false);
-		});
-	});
-
-	test('should validate username constraints', () => {
-		const validUsernames = ['user', 'testuser', 'user123', 'user_name', 'a'];
-		const invalidUsernames = ['', '   ', '  \t  ', '  \n  '];
-
-		validUsernames.forEach((username) => {
-			expect(username.trim().length).toBeGreaterThan(0);
-		});
-
-		invalidUsernames.forEach((username) => {
-			expect(username.trim().length).toBe(0);
-		});
-	});
-
-	test('should validate password strength', () => {
-		const strongPasswords = [
-			'password123',
-			'SecurePass!',
-			'MyP@ssw0rd',
-			'LongPassword123',
-		];
-		const weakPasswords = ['123', '', 'pass', '12345'];
-
-		strongPasswords.forEach((password) => {
-			expect(password.length).toBeGreaterThanOrEqual(6);
-		});
-
-		weakPasswords.forEach((password) => {
-			expect(password.length).toBeLessThan(6);
-		});
-	});
-
-	test('should handle validation errors gracefully', () => {
-		const invalidUser = new UserValidation();
-		invalidUser.email = 'invalid';
-		invalidUser.username = '';
-		invalidUser.password = '123';
-
-		// Collect validation errors
-		const errors: string[] = [];
-
-		if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(invalidUser.email)) {
-			errors.push('Invalid email format');
-		}
-
-		if (!invalidUser.username.trim()) {
-			errors.push('Username is required');
-		}
-
-		if (invalidUser.password.length < 6) {
-			errors.push('Password must be at least 6 characters');
-		}
-
-		expect(errors).toHaveLength(3);
-		expect(errors).toContain('Invalid email format');
-		expect(errors).toContain('Username is required');
-		expect(errors).toContain('Password must be at least 6 characters');
-	});
-});

package/app.ts

@@ -1,51 +0,0 @@
-import express, { Express } from 'express';
-import cors from 'cors';
-import morgan from 'morgan';
-import { IApp } from './interfaces/app.interface';
-import { IConfig } from './interfaces/config.interface';
-import { buildApp } from './rest';
-import { Container, multiInject } from 'inversify';
-import { SwaggerIntegration } from './swagger';
-import { MINI_TYPES } from './types';
-
-class App implements IApp {
-	app: Express;
-	container: Container;
-
-	constructor(@multiInject(MINI_TYPES.IController) private controllers: any[]) {
-		this.app = express();
-		this.container = new Container();
-	}
-
-	async init(config: IConfig) {
-		this.app.use(express.json());
-		this.app.use(express.urlencoded({ extended: true }));
-		this.app.use(cors());
-		this.app.use(morgan('dev'));
-		this.app.listen(config.port, () => {
-			console.log(`Server is running on port ${config.port}`);
-		});
-		const swaggerIntegration = new SwaggerIntegration({
-			title: config.applicationName,
-			description: `API documentation for ${config.applicationName}`,
-			version: '1.0.0',
-			servers: [
-				{
-					url: `http://${config.host}:${config.port}`,
-					description: 'Development server',
-				},
-			],
-			docsPath: '/api-docs',
-			jsonPath: '/api-docs.json',
-		});
-		swaggerIntegration.generateSwaggerSpec(this.controllers);
-		swaggerIntegration.setupSwagger(this.app);
-		buildApp(this.app, this.controllers);
-	}
-
-	async afterInit() {
-		console.log('afterInit');
-	}
-}
-
-export default App;

package/container.ts

@@ -1,7 +0,0 @@
-import { Container } from 'inversify';
-import App from './app';
-
-const container = new Container();
-container.bind(App).toSelf();
-
-export default container;

package/expections/http.expection.ts

@@ -1,147 +0,0 @@
-export interface IValidationError {
-	field: string;
-	errors: string[];
-}
-export interface IErrorMessage {
-	validationErrors?: IValidationError[];
-	message?: string;
-	errorId?: number;
-}
-
-export default class HttpException extends Error {
-	code: number;
-	message: string;
-	messageJson: IErrorMessage;
-	constructor(message: IErrorMessage, code = 500) {
-		super(JSON.stringify(message));
-		this.code = code;
-		this.message = JSON.stringify(message);
-		this.messageJson = message;
-		Error.captureStackTrace(this, this.constructor);
-	}
-}
-
-export class BadRequestException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 400);
-	}
-}
-
-export class UnauthorizedException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 401);
-	}
-}
-
-export class PaymentRequiredException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 402);
-	}
-}
-
-export class ForbiddenException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 403);
-	}
-}
-
-export class NotFoundException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 404);
-	}
-}
-
-export class MethodNotAllowedException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 405);
-	}
-}
-
-export class NotAcceptableException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 406);
-	}
-}
-
-export class ConflictException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 409);
-	}
-}
-
-export class GoneException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 410);
-	}
-}
-
-export class LengthRequiredException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 411);
-	}
-}
-
-export class PreconditionFailedException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 412);
-	}
-}
-
-export class PayloadTooLargeException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 413);
-	}
-}
-
-export class UnsupportedMediaTypeException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 415);
-	}
-}
-
-export class UnprocessableEntityException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 422);
-	}
-}
-
-export class TooManyRequestsException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 429);
-	}
-}
-
-export class InternalServerErrorException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 500);
-	}
-}
-
-export class NotImplementedException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 501);
-	}
-}
-
-export class BadGatewayException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 502);
-	}
-}
-
-export class ServiceUnavailableException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 503);
-	}
-}
-
-export class GatewayTimeoutException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 504);
-	}
-}
-export class ExpiredException extends HttpException {
-	constructor(error: IErrorMessage) {
-		super(error, 410);
-	}
-}

package/interfaces/app.interface.ts

@@ -1,6 +0,0 @@
-import { IConfig } from './config.interface';
-
-export interface IApp {
-	init(config: IConfig): Promise<void>;
-	afterInit(): Promise<void>;
-}

package/interfaces/authenticated.interface.ts

@@ -1,3 +0,0 @@
-export interface IAuthenticatedRequest extends Request {
-	authenticated: boolean;
-}

package/interfaces/config.interface.ts

@@ -1,5 +0,0 @@
-export interface IConfig {
-	host: string;
-	port: number;
-	applicationName: string;
-}

package/interfaces/queue.interface.ts

@@ -1,5 +0,0 @@
-export interface IQueue{
-    connection:any;
-    on:(eventName:string, event:any) => void;
-    emit:(eventName:string, event:any) => void;
-}

package/interfaces/repository.interface.ts

@@ -1,32 +0,0 @@
-import { Document } from 'mongoose';
-
-export interface IRepository<IdentifierType, ModelType> {
-	findAll(): Promise<
-		(ModelType & { id: string; createdAt: Date; updatedAt: Date })[]
-	>;
-	findById(
-		id: IdentifierType
-	): Promise<
-		(ModelType & { id: string; createdAt: Date; updatedAt: Date }) | null
-	>;
-	create(
-		item: ModelType
-	): Promise<ModelType & { id: string; createdAt: Date; updatedAt: Date }>;
-	update(
-		id: IdentifierType,
-		item: Partial<ModelType>
-	): Promise<ModelType & { id: string; createdAt: Date; updatedAt: Date }>;
-	delete(id: IdentifierType): Promise<void>;
-	findPaginated(
-		query: Partial<ModelType>,
-		page: number,
-		limit: number
-	): Promise<(ModelType & { id: string; createdAt: Date; updatedAt: Date })[]>;
-	mapper(
-		model: ModelType &
-			Document<IdentifierType, {}, ModelType> & {
-				createdAt: Date;
-				updatedAt: Date;
-			}
-	): ModelType & { id: string; createdAt: Date; updatedAt: Date };
-}

package/middlewares/authenticated.middleware.ts

@@ -1,15 +0,0 @@
-import { NextFunction, Response } from 'express';
-import { UnauthorizedException } from '../expections/http.expection';
-import { IAuthenticatedRequest } from '../interfaces/authenticated.interface';
-
-export const authenticatedMiddleware = (
-	req: IAuthenticatedRequest,
-	_res: Response,
-	next: NextFunction
-) => {
-	if (req.authenticated) next();
-	else
-		throw new UnauthorizedException({
-			message: 'Unauthorized',
-		});
-};

package/middlewares/authorized.middleware.ts

@@ -1,19 +0,0 @@
-import { NextFunction, Request, Response } from 'express';
-import { ForbiddenException } from '../expections/http.expection';
-
-export const authorizedMiddleware = (permissions: string[]) => {
-	return (
-		req: Request & { user: { permissions: string[] } },
-		_res: Response,
-		next: NextFunction
-	) => {
-		if (
-			permissions.some((permission) => req.user.permissions.includes(permission))
-		)
-			next();
-		else
-			throw new ForbiddenException({
-				message: 'Forbidden',
-			});
-	};
-};