@galeh/chuka 1.1.2 → 1.1.4

package/src/app.ts

@@ -1,197 +0,0 @@
-import 'reflect-metadata';
-import * as express from 'express';
-import { Container, interfaces } from "inversify";
-import * as inversify from "inversify";
-import { Controller, RequestHandlerParams, getRouterSymbol, setControllerSymbol } from './controller';
-import * as ws from 'express-ws';
-
-export function createApp(config: ApplicationConfig): express.Application {
-    const app = express.default();
-
-    if (config.on) {
-        setEventCallbacks(app, config.on);
-    }
-
-    if (config.set) {
-        applySettings(app, config.set);
-    }
-
-    ws.default(app);
-
-    if (config.middlewares) {
-        app.use.apply(app, config.middlewares as any);
-    }
-
-    const controllerEmulator = new ControllerEmulator(app);
-    const container = new Container();
-    initAllDependencies(config, container);
-    initControllers(config.routes, container, controllerEmulator as any as Controller);
-
-    return app;
-}
-
-function setEventCallbacks(app: express.Application, settings: EventCallback[]): void {
-    for (const setting of settings) {
-        app.on(setting.event, setting.callback);
-    }
-}
-
-function applySettings(app: express.Application, settings: Partial<Settings>): void {
-    for (const [key, value] of Object.entries(settings)) {
-        // @ts-ignore
-        app.set(SettingsEnum[key], value);
-    }
-}
-
-function initAllDependencies(config: ApplicationConfig, container: Container): void {
-    if (config.dependencies) {
-        initDependencies(config.dependencies, container);
-    }
-
-    initControllersAsDependency(config.routes, container);
-}
-
-function initDependencies(dependencies: Array<Dependency>, container: Container): void {
-    for (const dep of dependencies) {
-        if (dep.useValue) {
-            bindValue(container, dep.provide, dep.useValue);
-            continue;
-        }
-
-        if (dep.useClass) {
-            bindClass(container, dep.provide, dep.useClass);
-            continue;
-        }
-    }
-}
-
-function initControllersAsDependency(routes: Array<Route>, container: Container): void {
-    for (const route of routes) {
-        bindClass(container, route.controller, route.controller);
-        if (route.children) {
-            initControllersAsDependency(route.children, container);
-        }
-    }
-}
-
-function bindClass<T>(container: Container, token: Type<T> | string, classtype: Type<any>): void {
-    if (!container.isBound(token)){
-        container.bind<any>(token).to(classtype as any as interfaces.Newable<any>);
-    }
-}
-
-function bindValue(container: Container, token: string, value: any): void {
-    if (!container.isBound(token)) {
-        container.bind<any>(token).toConstantValue(value);
-    }
-}
-
-function bindFactory(container: Container, token: string, factory: inversify.interfaces.FactoryCreator<unknown>): void {
-    if (!container.isBound(token)) {
-        container.bind<any>(token).toFactory(factory);
-    }
-}
-
-
-function initControllers(routes: Array<Route>, container: Container, app: Controller): void {
-    for (const route of routes) {
-        const controller = container.get<Controller>(route.controller);
-        app[setControllerSymbol](route.path, controller);
-
-        if (route.children) {
-            initControllers(route.children, container, controller);
-        }
-    }
-}
-
-class ControllerEmulator {
-    constructor(private app: express.Application) {}
-
-    private [setControllerSymbol](path: string, subrouter: Controller): void {
-        this.app.use(path, subrouter[getRouterSymbol]());
-    }
-}
-
-interface Type<T> extends Function {
-    new(...args: any[]): T;
-}
-
-interface Dependency {
-    provide: string;
-    useClass?: Type<any>;
-    useValue?: any;
-}
-
-interface Route {
-    path: PathParams;
-    controller: Type<Controller>;
-    children?: Array<Route>;
-}
-
-interface ApplicationConfig {
-    routes: Array<Route>;
-    dependencies?: Array<Dependency>;
-    middlewares?: Array<RequestHandlerParams<any>>;
-    on?: EventCallback[];
-    set?: Partial<Settings>;
-}
-
-type EventCallback = {
-    event: 'connect' | 'connection' | 'close' | 'error' | 'listening' | 'lookup' | 'ready' | 'timeout' | 'mount';
-    callback: (parent: express.Application) => void
-};
-
-interface Settings extends Record<SettingsEnumKeys, any>{
-    caseSensitiveRouting: boolean;
-    env: string;
-    etag: any;
-    jsonpCallbackName: string;
-    jsonEscape: boolean;
-    jsonReplacer: any;
-    jsonSpaces: any;
-    queryParser: any;
-    strictRouting: boolean;
-    subdomainOffset: number;
-    trustProxy: any;
-    views: string | string[];
-    viewCache: boolean;
-    viewEngine: string;
-    xPoweredBy: boolean;
-}
-
-class SettingsEnum implements Record<SettingsEnumKeys, string>{
-    caseSensitiveRouting = 'case sensitive routing';
-    env = 'env';
-    etag = 'etag';
-    jsonpCallbackName = 'jsonp callback name';
-    jsonEscape = 'json escape'
-    jsonReplacer = 'json replacer';
-    jsonSpaces = 'json spaces';
-    queryParser = 'query parser';
-    strictRouting = 'strict routing';
-    subdomainOffset = 'subdomain offset';
-    trustProxy = 'trust proxy';
-    views = 'views';
-    viewCache = 'view cache';
-    viewEngine = 'view engine';
-    xPoweredBy = 'x-powered-by';
-}
-
-type SettingsEnumKeys = 
-    'caseSensitiveRouting' |
-    'env' |
-    'etag' |
-    'jsonpCallbackName' |
-    'jsonEscape' |
-    'jsonReplacer' |
-    'jsonSpaces' |
-    'queryParser' |
-    'strictRouting' |
-    'subdomainOffset' |
-    'trustProxy' |
-    'views' |
-    'viewCache' |
-    'viewEngine' |
-    'xPoweredBy';
-
-export type PathParams = string | RegExp | Array<string | RegExp>;

package/src/controller.ts

@@ -1,204 +0,0 @@
-import { Request, Response, NextFunction, Router } from 'express';
-import { injectable } from 'inversify';
-import { WebSocket } from 'ws';
-
-export const getRouterSymbol = Symbol();
-export const setControllerSymbol = Symbol();
-
-
-export type RequestHandlerParams<T> = Middleware<T> | ErrorHandler<T>;
-
-export interface Middleware<T> {
-    (
-        req: MergePartial<Request, T>,
-        res: Response,
-        next: NextFunction
-    ): void;
-}
-
-export interface ErrorHandler<T> {
-    (
-        err: any,
-        req: MergePartial<Request, T>,
-        res: Response,
-        next: NextFunction,
-    ): void;
-}
-
-@injectable()
-export class Controller {
-    private router: Router;
-
-    constructor() {
-        this.router = Router();
-    }
-
-    private [setControllerSymbol](path: any, subrouter: Controller): void {
-        this.router.use(path, subrouter[getRouterSymbol]());
-    }
-
-    private [getRouterSymbol](): Router {
-        return this.router;
-    }
-
-    protected useWS<M0>(): MiniControllerWS<M0>;
-    protected useWS<M0>(middleware0: WSMiddleware<M0>): MiniControllerWS<M0>;
-    protected useWS<M0, M1>(middleware0: WSMiddleware<M0>, middleware1: WSMiddleware<M1>): MiniControllerWS<M0 & M1>;
-    protected useWS<M0, M1, M2>(middleware0: WSMiddleware<M0>, middleware1: WSMiddleware<M1>, middleware2: WSMiddleware<M2>): MiniControllerWS<M0 & M1 & M2>;
-    protected useWS<M0, M1, M2, M3>(middleware0: WSMiddleware<M0>, middleware1: WSMiddleware<M1>, middleware2: WSMiddleware<M2>, middleware3: WSMiddleware<M3>): MiniControllerWS<M0 & M1 & M2 & M3>;
-    protected useWS(...middlewares: Array<unknown>): MiniControllerWS<unknown> {
-        return (handler) => {
-            (this.router as any).ws.apply(this.router, ['/', ...middlewares, handler]);
-        }
-    }
-
-    protected use<M0>(): MiniController<M0>;
-    protected use<M0>(middleware0: RequestHandlerParams<M0>): MiniController<M0>;
-    protected use<M0, M1>(middleware0: RequestHandlerParams<M0>, middleware1: RequestHandlerParams<M1>): MiniController<M0 & M1>;
-    protected use<M0, M1, M2>(middleware0: RequestHandlerParams<M0>, middleware1: RequestHandlerParams<M1>, middleware2: RequestHandlerParams<M2>): MiniController<M0 & M1 & M2>;
-    protected use<M0, M1, M2, M3>(middleware0: RequestHandlerParams<M0>, middleware1: RequestHandlerParams<M1>, middleware2: RequestHandlerParams<M2>, middleware3: RequestHandlerParams<M3>): MiniController<M0 & M1 & M2 & M3>;
-    protected use(...middlewares: Array<unknown>): MiniController<unknown> {    
-        return new MiniController(this.router, middlewares);
-    }
-}
-
-type WSHandler<T> = (ws: WebSocket, req: Merge<Request, T>) => void;
-export type WSMiddleware<T> = (ws: WebSocket, req: MergePartial<Request, T>, next: NextFunction) => void
-
-interface MiniControllerWS<T> {
-    (handler: WSHandler<T>): void;
-}
-
-interface MiniControllerInterface<T> {
-    all: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    get: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    post: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    put: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    delete: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    patch: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    options: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    head: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-
-    checkout: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    connect: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    copy: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    lock: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    merge: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    mkactivity: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    mkcol: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    move: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    "m-search": <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    notify: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    propfind: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    proppatch: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    purge: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    report: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    search: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    subscribe: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    trace: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    unlock: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    unsubscribe: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    link: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-    unlink: <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void;
-}
-
-class MiniController<T> implements MiniControllerInterface<T> {
-    constructor(
-        private router: any,
-        private middlewares: any[]
-    ) { }
-    
-    all = this.methodImplementation('all').bind(this);
-    get = this.methodImplementation('get').bind(this);
-    post = this.methodImplementation('post').bind(this);
-    put = this.methodImplementation('put').bind(this);
-    delete = this.methodImplementation('delete').bind(this);
-    patch = this.methodImplementation('patch').bind(this);
-    options = this.methodImplementation('options').bind(this);
-    head = this.methodImplementation('head').bind(this);
-    
-    checkout = this.methodImplementation('checkout').bind(this);
-    connect = this.methodImplementation('connect').bind(this);
-    copy = this.methodImplementation('copy').bind(this);
-    lock = this.methodImplementation('lock').bind(this);
-    merge = this.methodImplementation('merge').bind(this);
-    mkactivity = this.methodImplementation('mkactivity').bind(this);
-    mkcol = this.methodImplementation('mkcol').bind(this);
-    move = this.methodImplementation('move').bind(this);
-    'm-search' = this.methodImplementation('m-search').bind(this);
-    notify = this.methodImplementation('notify').bind(this);
-    propfind = this.methodImplementation('propfind').bind(this);
-    proppatch = this.methodImplementation('proppatch').bind(this);
-    purge = this.methodImplementation('purge').bind(this);
-    report = this.methodImplementation('report').bind(this);
-    search = this.methodImplementation('search').bind(this);
-    subscribe = this.methodImplementation('subscribe').bind(this);
-    trace = this.methodImplementation('trace').bind(this);
-    unlock = this.methodImplementation('unlock').bind(this);
-    unsubscribe = this.methodImplementation('unsubscribe').bind(this);
-    link = this.methodImplementation('link').bind(this);
-    unlink = this.methodImplementation('unlink').bind(this);
-
-
-    private methodImplementation(methodName: PropertyKey): <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>)=> void {
-        return <Path extends string>(path: Path, handler: RequestHandler<T, RouteParameters<Path>>): void => {
-            this.router[methodName].apply(this.router, [
-                path,
-                ...this.middlewares,
-                (req: any, res: any, next: any) => {
-                    handler(req, res, next);
-                }
-            ]);
-        }
-    }
-
-    use<M0>(middleware0: RequestHandlerParams<M0>): MiniController<Merge<T, M0>>;
-    use<M0, M1>(middleware0: RequestHandlerParams<M0>, middleware1: RequestHandlerParams<M1>): MiniController<Merge<T, M0 & M1>>;
-    use<M0, M1, M2>(middleware0: RequestHandlerParams<M0>, middleware1: RequestHandlerParams<M1>, middleware2: RequestHandlerParams<M2>): MiniController<Merge<T, M0 & M1 & M2>>;
-    use<M0, M1, M2, M3>(middleware0: RequestHandlerParams<M0>, middleware1: RequestHandlerParams<M1>, middleware2: RequestHandlerParams<M2>, middleware3: RequestHandlerParams<M3>): MiniController<Merge<T, M0 & M1 & M2 & M3>>;
-    use<S>(...middlewares: Array<Middleware<S>>): MiniController<S> {    
-        return new MiniController(this.router, this.middlewares.concat(middlewares));
-    }
-}
-
-interface RequestHandler<
-    T,
-    P = ParamsDictionary
-> {
-    (
-        req: Merge<Request, T & { params: P }>,
-        res: Response,
-        next: NextFunction
-    ): void;
-}
-
-
-export type Merge<A, B> = {
-    [k in keyof A & keyof B]: (A & B)[k] extends never ? B[k] : 0 extends 1 & (A & B)[k] ? B[k] : (A & B)[k];
-} & Omit<A, keyof B> & Omit<B, keyof A>;
- 
-export type MergePartial<A, B> = {
-    [k in keyof A & keyof B]: (A & B)[k] extends never ? B[k] : 0 extends 1 & (A & B)[k] ? B[k] : (A & B)[k];
-} & Omit<A, keyof B> & Partial<Omit<B, keyof A>>;
-
-interface ParamsDictionary {
-    [key: string]: string;
-}
-
-export type RouteParameters<Route extends string> = string extends Route ? ParamsDictionary
-    : Route extends `${string}(${string}` ? ParamsDictionary // TODO: handling for regex parameters
-    : Route extends `${string}:${infer Rest}` ?
-            & (
-                GetRouteParameter<Rest> extends never ? ParamsDictionary
-                    : GetRouteParameter<Rest> extends `${infer ParamName}?` ? { [P in ParamName]?: string }
-                    : { [P in GetRouteParameter<Rest>]: string }
-            )
-            & (Rest extends `${GetRouteParameter<Rest>}${infer Next}` ? RouteParameters<Next> : unknown)
-    : {};
-
-type GetRouteParameter<S extends string> = RemoveTail<
-    RemoveTail<RemoveTail<S, `/${string}`>, `-${string}`>,
-    `.${string}`
->;
-
-type RemoveTail<S extends string, Tail extends string> = S extends `${infer P}${Tail}` ? P : S;

package/src/decorators/index.ts

@@ -1 +0,0 @@
-export { inject, injectable } from 'inversify';

package/src/index.ts

@@ -1,3 +0,0 @@
-export { interfaces } from 'inversify';
-export { createApp } from './app';
-export { Controller, Middleware, WSMiddleware } from './controller';

package/src/middlewares/index.ts

@@ -1 +0,0 @@
-export { json, static, urlencoded, query, raw, text } from 'express';

package/src/validators/body-validator.ts

@@ -1,9 +0,0 @@
-import { Middleware } from "..";
-import { validator } from ".";
-import { ValidationLogic } from "./validators";
-
-export function bodyValidator<T>(validationLogic: ValidationLogic<T>): Middleware< { body: T }> {
-    return (req, res, next) => {
-        validator(validationLogic, 'body')(req, res, next);
-    }
-}

package/src/validators/index.ts

@@ -1,2 +0,0 @@
-export { and, isDefined, isNull, isNumber, isString, isUndefined, not, notNull, or, validator, ValidationLogic, custom } from './validators';
-export { bodyValidator } from './body-validator';

package/src/validators/query-validator.ts

@@ -1,9 +0,0 @@
-import { Middleware } from "..";
-import { validator } from ".";
-import { ValidationLogic } from "./validators";
-
-export function queryValidator<T>(validationLogic: ValidationLogic<T>): Middleware< { query: T }> {
-    return (req, res, next) => {
-        validator(validationLogic, 'query')(req, res, next);
-    }
-}

package/src/validators/validators.ts

@@ -1,216 +0,0 @@
-import { Middleware } from '../controller';
-
-type RequestField<F extends PropertyKey, T> = Record<F, T>;
-
-export function validator<T, F extends PropertyKey>(validationLogic: ValidationLogic<T>, requestField: F): Middleware<RequestField<F, T>> {
-    return (req, res, next) => {
-        // @ts-ignore
-        applyValidation(req[requestField], validationLogic).then(errors => {
-            const result = isThereAnyErrors(errors);
-            if (result) {
-                next(errors);
-            } else {
-                next();
-            }
-        }).catch(next);
-    
-    }
-}
-
-async function applyValidation<T>(obj: T, validationLogic: ValidationLogic<T>): Promise<Partial<Record<keyof T, any>>> {
-    const validationResult: Partial<Record<keyof T, any>> = {};
-
-    for (const key in validationLogic) {
-        const atomicValidator = validationLogic[key];
-
-        if (atomicValidator) {
-            if (atomicValidator instanceof Validator) {
-                try {
-                    validationResult[key] = atomicValidator.validate(obj, key);
-                    if (validationResult[key] as Object instanceof Promise) {
-                        validationResult[key] = await validationResult[key];
-                        console.log(`awaited result: ${validationResult[key]}`);
-                    }
-                } catch (err) {
-                    validationResult[key] = false;
-                }
-            } else {
-                if (obj[key] instanceof Array) {
-                    validationResult[key] = (obj[key] as Array<any>).map(objj => applyValidation(objj, atomicValidator));
-                    if (validationResult[key][0] instanceof Promise) {
-                        validationResult[key] = Promise.all(validationResult[key]);
-                    }
-                } else {
-                    validationResult[key] = applyValidation(obj[key], atomicValidator as any);
-                    if (validationResult[key] as Object instanceof Promise) {
-                        validationResult[key] = await validationResult[key];
-                    }
-                }
-            }
-        } else {
-            validationResult[key] = true;
-        }
-    }
-
-    return validationResult;
-}
-
-function isThereAnyErrors(obj: Object): boolean {
-    for (const [key, value] of Object.entries(obj)) {
-        if (value === false) {
-            return true;
-        } else if (typeof value !== 'boolean') {
-            const partialRes = isThereAnyErrors(value);
-            if (partialRes) {
-                return partialRes;
-            }
-        } 
-    }
-    return false;
-}
-
-type UnArray<T> = T extends Array<infer A> ? A : T;
-
-type ValidatorReturn = boolean | Promise<boolean>;
-
-export type ValidationLogic<T> = {
-    [k in keyof T as T[k] extends Function ? never : k]?: ValidationLogic<UnArray<T[k]>> | Validator<T>; 
-}
-
-// type ValidationFunction<T> = (subject: T) => boolean;
-
-export abstract class Validator<T> {
-    abstract validate(subject: T, selectedField: keyof T): ValidatorReturn;
-}
-
-
-class CustomValidator<T> extends Validator<T> {
-    constructor(private validator: (obj: T) => ValidatorReturn) {
-        super();
-    }
-
-    validate(subject: T, selectedField: keyof T): ValidatorReturn{
-        return this.validator(subject);
-    }
-}
-
-export function custom<T>(validator: (obj: T) => ValidatorReturn): Validator<T> {
-    return new CustomValidator(validator);
-}
-
-export class AtomicValidator<T> extends Validator<T> {
-    constructor(private implementation: (subject: T | T[keyof T]) => ValidatorReturn, public queryField?: keyof T) {
-        super();
-    }
-
-    validate(subject: T, selectedField: keyof T): ValidatorReturn {
-        return this.implementation(this.queryField ? subject[this.queryField] : subject[selectedField]);
-    }
-}
-
-export function isString<T>(field?: keyof T): AtomicValidator<T> {
-    return new AtomicValidator((subject) => {
-        return typeof subject === 'string';
-    }, field);
-}
-
-export function isNumber<T>(field?: keyof T): AtomicValidator<T> {
-    return new AtomicValidator((subject) => {
-        return typeof subject === 'number';
-    }, field);
-}
-
-export function isDefined<T>(field?: keyof T): AtomicValidator<T> {
-    return new AtomicValidator((subject) => {
-        return subject != undefined;
-    }, field);
-}
-
-export function isUndefined<T>(field?: keyof T): AtomicValidator<T> {
-    return new AtomicValidator((subject) => {
-        return subject === undefined;
-    }, field);
-}
-
-export function isNull<T>(field?: keyof T): AtomicValidator<T> {
-    return new AtomicValidator((subject) => {
-        return subject === null;
-    }, field);
-}
-
-export function notNull<T>(field?: keyof T): AtomicValidator<T> {
-    return new AtomicValidator((subject) => {
-        return subject !== null;
-    }, field);
-}
-
-
-class AndValidator<T> extends Validator<T> {
-    private validationFunctions: Array<Validator<T>>;
-
-    constructor(...validationFunctions: Array<Validator<T>>) {
-        super();
-        this.validationFunctions = validationFunctions;
-    }
-
-    validate(subject: T, selectedField: keyof T): ValidatorReturn {
-        return this.validationFunctions.every(eachValidator => eachValidator.validate(subject, selectedField));
-    }
-}
-
-class AndValidatorAsync<T> extends Validator<T> {
-    private validationFunctions: Array<Validator<T>>;
-
-    constructor(...validationFunctions: Array<Validator<T>>) {
-        super();
-        this.validationFunctions = validationFunctions;
-    }
-
-    async validate(subject: T, selectedField: keyof T): Promise<boolean> {
-        const allPromises = this.validationFunctions.map(eachValidator => eachValidator.validate(subject, selectedField));
-        const allResults = await Promise.all(allPromises);
-        return allResults.every(val => val);
-    }
-}
-
-class OrValidator<T> extends Validator<T> {
-    private validationFunctions: Array<Validator<T>>
-
-    constructor(...validationFunctions: Array<Validator<T>>) {
-        super();
-        this.validationFunctions = validationFunctions;
-    }
-
-    validate(subject: T, selectedField: keyof T): ValidatorReturn {
-        return this.validationFunctions.some(eachValidator => eachValidator.validate(subject, selectedField));
-    }
-}
-
-class NotValidator<T> extends Validator<T> {
-    private validationFunction: Validator<T>;
-
-    constructor(validationFunctions: Validator<T>) {
-        super();
-        this.validationFunction = validationFunctions;
-    }
-
-    validate(subject: T, selectedField: keyof T): ValidatorReturn {
-        return !this.validationFunction.validate(subject, selectedField);
-    }
-}
-
-export function and<T>(...validationFunctions: Array<Validator<T>>): Validator<T> {
-    return new AndValidator(...validationFunctions);
-}
-
-export function andAsync<T>(...validationFunctions: Array<Validator<T>>): Validator<T> {
-    return new AndValidatorAsync(...validationFunctions);
-}
-
-export function or<T>(...validationFunctions: Array<Validator<T>>): Validator<T> {
-    return new OrValidator(...validationFunctions);
-}
-
-export function not<T>(validationFunction: Validator<T>): Validator<T> {
-    return new NotValidator(validationFunction);
-}