web_api_base 1.0.0

package/.vscode/launch.json

@@ -0,0 +1,21 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Launch Program",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${file}",
+            "outFiles": [
+                "${workspaceFolder}/**/*.js"
+            ]
+        }
+    ]
+}

package/Application.ts

@@ -0,0 +1,39 @@
+import { Express } from "express";
+import ExpressModule from "express";
+import ApplicationConfiguration from "./ApplicationConfiguration"
+import IApplication from "./interfaces/IApplication";
+import IApplicationConfiguration from "./interfaces/IApplicationConfiguration";
+
+export default abstract class Application implements IApplication
+{
+
+    private ApplicationConfiguration : IApplicationConfiguration;
+
+    public Express : Express;
+
+
+    constructor()
+    {
+        this.ApplicationConfiguration = new ApplicationConfiguration();
+
+        this.Express = ExpressModule();
+
+    }
+    
+
+    public async StartAsync() : Promise<void>
+    {
+        await this.ApplicationConfiguration.StartAsync();
+
+        this.Configure(this.ApplicationConfiguration);
+
+        this.Express.listen(this.ApplicationConfiguration.Port, this.ApplicationConfiguration.Host, ()=>
+        {
+            console.log(`App running on ${this.ApplicationConfiguration.Host}:${this.ApplicationConfiguration.Port}`);
+        })
+    }
+
+    public abstract Configure(appConfig : IApplicationConfiguration): void;
+    
+    
+}

package/ApplicationConfiguration.ts

@@ -0,0 +1,82 @@
+import File from 'fs';
+
+import IApplicationConfiguration from './interfaces/IApplicationConfiguration';
+
+
+export default class Configuration implements IApplicationConfiguration
+{
+
+    public Host : string = "0.0.0.0";    
+    public Port : number = 5555;
+
+    constructor()
+    {
+        process.env["root_dir"] = __dirname;
+    }
+
+    public async StartAsync() : Promise<void>
+    {
+        if(!await this.CheckFileAsync())
+        {
+            await this.CreateFileAsync();
+            
+        }else{
+
+            await this.ReadFileAsync();
+        }
+    }
+
+    private async CheckFileAsync() : Promise<boolean>
+    {
+        return new Promise<boolean>((resolve, _) => resolve(File.existsSync(`${__dirname}\\config.json`)));        
+    }
+
+    private async ReadFileAsync() : Promise<boolean>
+    {
+        return new Promise<boolean>((resolve, _) => 
+        {
+            File.readFile(`${__dirname}\\config.json`, 'utf-8', (error, data) => 
+            {
+                if(error)
+                {
+                    throw error;
+                }
+
+                let json : any = JSON.parse(data);
+
+                for(let key in this)
+                {
+                    if(json[key] != undefined)
+                    {
+                        this[key] = json[key];
+                    }
+                }
+
+                resolve(true);
+
+            })
+        })
+    }
+
+    private async CreateFileAsync() : Promise<boolean>
+    {
+
+        return new Promise<boolean>((resolve, _)=>{
+
+            File.writeFile(`${__dirname}\\config.json`, JSON.stringify(this), 'utf-8', error => 
+            {
+                
+                if(error)
+                {
+                    throw error;
+                }
+
+                resolve(true);
+    
+            });   
+        })
+             
+    }
+
+}
+

package/__tests__/classes/Controller.ts

@@ -0,0 +1,38 @@
+/* istanbul ignore next */
+
+import { ControllerBase } from "../../controllers/base/ControllerBase";
+import ControllersDecorators from "../../decorators/controllers/ControllerDecorators";
+import { HTTPVerbs } from "../../enums/httpVerbs/HttpVerbs";
+import IApplication from "../../interfaces/IApplication";
+import {Request, Response} from 'express'
+
+@ControllersDecorators.Route("/test")
+export class ControllerTest extends ControllerBase
+{
+    constructor()
+    {
+        super();
+    }
+
+    @ControllersDecorators.Action("Test")
+    @ControllersDecorators.Verb(HTTPVerbs.GET)
+    @ControllersDecorators.Argument<string>('name')
+    public TestAction(name : string)
+    {
+        console.log(name);
+    }
+
+    @ControllersDecorators.Action("Test")
+    @ControllersDecorators.Verb(HTTPVerbs.GET)
+    @ControllersDecorators.Argument<string, number>('name', 'age')
+    public TestActionTwo(name : string, age : number)
+    {
+        console.log(name, age);
+    }
+
+
+    public AppendSync(application: IApplication): void 
+    {
+        
+    }
+}

package/__tests__/decorators/controllers/ControllerDecorators.spec.ts

@@ -0,0 +1,67 @@
+import { ControllerTest } from "../../classes/Controller";
+import ControllersDecorators from "../../../decorators/controllers/ControllerDecorators";
+import { HTTPVerbs } from "../../../enums/httpVerbs/HttpVerbs";
+
+describe('testing controllers decorators', ()=>
+{
+
+    test("action name", ()=>
+    {
+        var controller = new ControllerTest();
+        let action = ControllersDecorators.GetAction(controller, "TestAction");
+        expect(action).toBe("Test");
+
+    },10^5)
+
+    test("http verb", ()=>
+    {
+        var controller = new ControllerTest();
+        let verb = ControllersDecorators.GetVerb(controller, "TestAction");
+        expect(verb).toBe(HTTPVerbs.GET);
+
+    },10^5)
+
+    test("action with one arg", ()=>
+    {
+        var controller = new ControllerTest();
+        
+        var handler = ControllersDecorators.GetArgumentsHandler(controller, 'TestAction');
+
+        var arr = handler?.CreateArgumentsList({name : "adriano"});
+
+        Reflect.apply(controller.TestAction, controller, arr ?? []);
+
+        expect(arr).not.toBeNull();
+
+
+    },10^5)
+
+
+    test("action with two args", ()=>
+    {
+        var controller = new ControllerTest();
+        
+        var handler = ControllersDecorators.GetArgumentsHandler(controller, 'TestActionTwo');
+
+        var arr = handler?.CreateArgumentsList({name : "adriano", age : 30});
+
+        Reflect.apply(controller.TestActionTwo, controller, arr ?? []);
+
+        expect(arr).not.toBeNull();
+
+
+    },10^5)
+
+
+    test("controller route", ()=>
+    {
+        var controller = new ControllerTest();
+        
+        var route = ControllersDecorators.GetRoute(controller);
+        
+        expect(route!).toBe("/test");
+
+
+    },10^5)
+
+})

package/controllers/base/ControllerBase.ts

@@ -0,0 +1,116 @@
+import IController from "../../interfaces/IController";
+import {Request, Response} from 'express'
+import ControllersDecorators from '../../decorators/controllers/ControllerDecorators';
+import DependecyService from '../../dependencyInjection/DependecyService';
+import IApplication from "../../interfaces/IApplication";
+import { HTTPVerbs } from "../../enums/httpVerbs/HttpVerbs";
+
+
+export class ControllerBase implements IController
+{
+    Request : Request = {} as Request;
+    Response : Response = {} as Response;
+
+    constructor()
+    {
+        
+    }
+
+    public OK<T>(result : T)
+    {
+        this.Response.status(200);
+        this.Response.json(result);
+    }
+
+    public Created()
+    {
+        this.Response.status(201);
+        this.Response.end();
+    }
+    
+    public BadRequest<T>(result : T)
+    {
+        this.Response.status(400);
+        this.Response.json(result);
+    }
+
+    public Error<T>(result : T)
+    {
+        this.Response.status(500);
+        this.Response.json(result);
+    }
+
+    public SendResponse<T>(status : number, result : T)
+    {
+        this.Response.status(status);
+        this.Response.json(result);
+    }
+
+    public static AppendController<T extends IController>(ctor : { new (...args : any[]) : T;}, application : IApplication) : void
+    {
+        let empty = new ctor() as any;
+                
+        let methods = Reflect.ownKeys(empty.constructor.prototype).filter(m => 
+            {
+                return typeof empty[m] == "function" ;
+            })     
+
+        let route = ControllersDecorators.GetRoute(empty);
+
+        if(!route)
+            return;
+
+
+        for(let method of methods)
+        {
+            let action = ControllersDecorators.GetAction(empty, method.toString());
+
+            if(!action){
+                continue;                
+            }
+            
+            let verb = ControllersDecorators.GetVerb(empty, method.toString());
+
+            if(!verb)
+                verb = HTTPVerbs.GET;
+
+            console.debug("appended : " , verb,`${route}${action}`);
+
+            (application.Express as any)[verb.toString().toLowerCase()](`${route}${action}`, (req : Request, resp : Response) => 
+            {
+
+                let midlewares = ControllersDecorators.GetMidlewares(empty).reverse();
+
+                midlewares.push(...ControllersDecorators.GetBefores(empty, method.toString()).reverse());
+
+                if(midlewares)
+                {
+                    for(let method of midlewares)
+                    {
+                        method(req);
+                    }
+                }
+
+                let args = ControllersDecorators.GetArgumentsHandler(empty, method.toString());
+                let params = [];
+                
+                if(args)
+                {
+                    if(args.Arguments.length > 0)
+                    {
+                        if(req.body && verb == (HTTPVerbs.POST || verb == HTTPVerbs.PUT))
+                            params = args.CreateArgumentsList(req.body);
+                        if(req.query)
+                            params.push(...args.CreateArgumentsList(req.query))
+                    }
+                }
+
+                let controller = DependecyService.ResolveCtor(empty.constructor) as IController;
+                controller.Request = req;
+                controller.Response = resp;
+                (controller as any)[method](...params);
+            })
+        }
+                
+    }
+}

package/decorators/controllers/ControllerDecorators.ts

@@ -0,0 +1,187 @@
+import { REFUSED } from 'dns';
+import 'reflect-metadata';
+
+import { HTTPVerbs } from '../../enums/httpVerbs/HttpVerbs';
+import IController from '../../interfaces/IController';
+import IMidleware from '../../midlewares/IMidleware';
+
+export default class ControllersDecorators
+{
+    constructor()
+    {
+
+    }
+
+    private static RouteKeyMetadata = "meta:controllerRoute";
+    private static ActionVerbKeyMetadata = "meta:actionVerb";
+    private static ActionNameKeyMetadata = "meta:actionName";
+    private static ArgumentsHandlerKeyMetadata = "meta:argHandler";
+    private static ControllerMidlewaresKeyMetadata = "meta:controllerMidlewaresKey";
+    private static ActionsMidlewaresKeyMetadata = "meta:actionMidlewaresKey";
+    
+
+    public static Route(route : string)  
+    {
+        return function( target : Function)
+        {
+            Reflect.defineMetadata(ControllersDecorators.RouteKeyMetadata, route, target);
+            
+        }
+    }
+
+    public static Use(midleware : IMidleware)  
+    {
+        return function( target : Function)
+        {
+            let current : IMidleware[] = Reflect.getMetadata(ControllersDecorators.ControllerMidlewaresKeyMetadata, target) ?? [];
+
+            current.push(midleware);
+
+            Reflect.defineMetadata(ControllersDecorators.ControllerMidlewaresKeyMetadata, current, target);            
+        }
+    }
+
+    public static GetMidlewares(controller : IController) : IMidleware[]
+    {
+       return Reflect.getMetadata(ControllersDecorators.ControllerMidlewaresKeyMetadata, controller.constructor) ?? [];
+    }
+
+    public static Before(midleware : IMidleware)  
+    {
+        return function( target : Object, methodName : string, propertyDescriptor : PropertyDescriptor)
+        {
+            let current : IMidleware[] = Reflect.getMetadata(ControllersDecorators.ActionsMidlewaresKeyMetadata, target, methodName) ?? [];
+
+            current.push(midleware);
+
+            ControllersDecorators.SetMetaData(ControllersDecorators.ActionsMidlewaresKeyMetadata, target, methodName, current);
+            
+        }
+    }
+
+    public static GetBefores(controller : IController, methodName : string) : IMidleware[]
+    {
+       return this.GetMetaData<IMidleware[]>(ControllersDecorators.ActionsMidlewaresKeyMetadata, controller, methodName) ?? [];
+    }
+
+    public static GetRoute(controller : IController) : string | undefined
+    {
+       return Reflect.getMetadata(ControllersDecorators.RouteKeyMetadata, controller.constructor);
+    }
+
+
+    public static Verb(verb : HTTPVerbs)  
+    {
+        return function( target : Object, methodName : string, propertyDescriptor : PropertyDescriptor)
+        {
+            ControllersDecorators.SetMetaData(ControllersDecorators.ActionVerbKeyMetadata, target, methodName, verb);
+            
+        }
+    }
+
+    public static GetVerb(target : IController, methodName : string ) : HTTPVerbs | undefined
+    {
+        let meta = this.GetMetaData<HTTPVerbs>(ControllersDecorators.ActionVerbKeyMetadata, target, methodName);
+
+        return meta;
+    }
+
+    public static Action(actionName : String)  
+    {
+        return function( target : Object, methodName : string, propertyDescriptor : PropertyDescriptor)
+        {
+            ControllersDecorators.SetMetaData(ControllersDecorators.ActionNameKeyMetadata, target, methodName, actionName);
+            
+        }
+    }
+
+    public static GetAction(target : IController, methodName : string ) : string | undefined
+    {
+        let meta = this.GetMetaData<string>(ControllersDecorators.ActionNameKeyMetadata, target, methodName);
+
+        return meta;
+    }
+   
+    
+    public static Argument<T>(argName1 : string) : ( target : Object, methodName : string, propertyDescriptor : PropertyDescriptor) => void
+    public static Argument<T, U>(argName1 : string, argName2?: string)  : ( target : Object, methodName : string, propertyDescriptor : PropertyDescriptor) => void
+    public static Argument<T, U, K>(argName1 : string, argName2?: string, argName3? : string)  : ( target : Object, methodName : string, propertyDescriptor : PropertyDescriptor) => void
+    public static Argument<T, U, K, Y>(argName1 : string, argName2?: string, argName3? : string, argName4? : string)  : ( target : Object, methodName : string, propertyDescriptor : PropertyDescriptor) => void
+    public static Argument<T, U, K, Y, J>(argName1 : string, argName2?: string, argName3? : string, argName4? : string, argName5? : string)  : ( target : Object, methodName : string, propertyDescriptor : PropertyDescriptor) => void
+    public static Argument<T, U, K, Y, J, V>(argName1 : string, argName2?: string, argName3? : string, argName4? : string, argName5? : string, argName6? : string)  : ( target : Object, methodName : string, propertyDescriptor : PropertyDescriptor) => void
+    {
+        return function( target : Object, methodName : string, propertyDescriptor : PropertyDescriptor)
+        {
+            ControllersDecorators.SetMetaData(ControllersDecorators.ArgumentsHandlerKeyMetadata, target, methodName, 
+                {
+                    
+
+                    Arguments : [argName1, argName2, argName3, argName4, argName5, argName6],
+
+                    CreateArgumentsList : (args : any) => 
+                    {
+                        let results = [] as any[];
+
+                        
+                        if (argName1 && (args[argName1] as unknown as T) != undefined) 
+                            results[0] = args[argName1] as T;
+
+                        if (argName2 && (args[argName2] as unknown as U) != undefined) 
+                            results[1] = args[argName2] as U;
+            
+                        if (argName3 && (args[argName3] as unknown as K) != undefined) 
+                            results[2] = args[argName3] as K;
+            
+                        if (argName4 && (args[argName4] as unknown as Y) != undefined) 
+                            results[3] = args[argName4] as Y;
+            
+                        if (argName5 && (args[argName5] as unknown as J) != undefined) 
+                            results[4] = args[argName5] as J;
+            
+                        if (argName6 && (args[argName6] as unknown as V) != undefined) 
+                            results[5] = args[argName6] as V;
+
+                        return results;
+
+                    } 
+                });
+            
+        }
+    }
+
+    
+
+    public static GetArgumentsHandler(target : IController, methodName : string ) : IArgumentResolverHandler | undefined
+    {
+        let handler = this.GetMetaData<IArgumentResolverHandler>(ControllersDecorators.ArgumentsHandlerKeyMetadata, target, methodName);
+
+        return handler;
+    }
+    
+    private static SetMetaData<T>(key: string, target : Object, methodName : string, value : T)
+    {
+        var meta = Reflect.getOwnMetadata(key, target as Object, methodName);
+    
+        if(!meta)
+            Reflect.defineMetadata(key, value, target as Object, methodName);
+    }
+
+
+    private static GetMetaData<T>(key: string, target : Object, methodName : string) : T | undefined
+    {
+        var meta = Reflect.getMetadata(key, target, methodName);
+    
+        if(meta != undefined)
+            return meta as T;
+        else 
+            return undefined;
+    }    
+
+}
+interface IArgumentResolverHandler
+{
+    Arguments : string[];
+    CreateArgumentsList : (args :any) => any[];
+}
+
+

package/dependencyInjection/DependecyService.ts

@@ -0,0 +1,36 @@
+export default class DependecyService
+{
+    private static _services : IService[] = [];
+
+    public static RegisterFor(type : Function, ctor : { new (...args : any[]) : any;}, builder? : () => any) : void    
+    {        
+        let defaultBuilder = () =>  Reflect.construct(ctor ?? type, []) as any;
+
+        this._services.push({ Type : type, Builder : builder ?? defaultBuilder });        
+    }
+
+    public static Register(type : Function, builder? : () => any) : void
+    {
+        let defaultBuilder = () => Reflect.construct(type, []);
+
+        this._services.push({ Type : type, Builder : builder ?? defaultBuilder });
+    }
+    
+    public static Resolve<T>(type : Function, args? : any[]) : T
+    {
+        return this._services.find(u => u.Type == type)?.Builder(args) as T;
+    }
+
+    public static ResolveCtor(ctor : Function, args? : any[]) : any
+    {
+        return this._services.find(u => u.Type == ctor)?.Builder(args);
+    }
+
+}
+
+
+interface IService
+{
+    Type : Function;
+    Builder : Function;
+}

package/enums/httpVerbs/HttpVerbs.ts

@@ -0,0 +1,7 @@
+export enum HTTPVerbs
+{
+    GET = "GET", 
+    POST = "POST", 
+    PUT = "PUT", 
+    DELETE = "DELETE"
+}

package/interfaces/IApplication.ts

@@ -0,0 +1,13 @@
+import { Express } from "express";
+import IApplicationConfiguration from './IApplicationConfiguration';
+
+import IController from "./IController";
+
+export default interface IApplication
+{
+    Express : Express;
+
+    StartAsync() : Promise<void>;    
+
+    Configure(appConfig : IApplicationConfiguration): void;
+}

package/interfaces/IApplicationConfiguration.ts

@@ -0,0 +1,6 @@
+export default interface IApplicationConfiguration
+{
+    Host : string;    
+    Port : number;
+    StartAsync() : Promise<void>
+}

package/interfaces/IController.ts

@@ -0,0 +1,8 @@
+import IApplication from "./IApplication";
+import {Request, Response} from 'express'
+
+export default interface IController
+{
+    Request : Request;
+    Response : Response;
+}

package/interfaces/entities/IDirectory.ts

@@ -0,0 +1,6 @@
+export interface IDirectory
+{
+    Path : string;
+    SubDirectories? : string[],
+    Files? : string[]
+}

package/jest.config.ts

@@ -0,0 +1,6 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  modulePathIgnorePatterns: ['<rootDir>/__test__/classes/'],
+};

package/midlewares/IMidleware.ts

@@ -0,0 +1,6 @@
+import { Request } from "express";
+
+export default interface IMidleware
+{
+    (req : Request) : void
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "web_api_base",
+  "version": "1.0.0",
+  "description": "web api base",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest",
+    "debug": "node ./dist/Index.js",
+    "transpile": "tsc -p tsconfig.json",
+    "run:tests": "npx jest"
+  },
+  "author": "adriano.marino1992@gmail.com",
+  "license": "ISC",
+  "dependencies": {
+    "@types/express": "^4.17.15",
+    "@types/jest": "^29.2.4",
+    "@types/node": "^18.11.17",
+    "@types/reflect-metadata": "^0.1.0",
+    "cors": "^2.8.5",
+    "express": "^4.18.2",
+    "formidable": "^2.1.1",
+    "jest": "^29.3.1",
+    "platform-folders": "^0.6.0",
+    "reflect-metadata": "^0.1.13",
+    "ts-jest": "^29.0.3",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.4"
+  },
+  "devDependencies": {
+    "@types/formidable": "^2.0.5"
+  }
+}

package/services/fileService/FileService.ts

@@ -0,0 +1,125 @@
+
+import File from 'fs';
+import FileAsync from 'fs/promises';
+import Path from 'path';
+import {getDesktopFolder} from 'platform-folders'
+
+import FileServiceBase from "./FileServiceBase";
+
+
+export default class FileService extends FileServiceBase
+{
+    
+
+    public override GetDefaultDir(): string {
+        
+        return getDesktopFolder();
+    }
+
+
+    public override CreateDirectory(path: string): Promise<void> {
+
+        return new Promise<void>(async (resolve, reject) => 
+        {           
+            try{
+
+               return resolve(File.mkdirSync(path));
+
+            }catch(err)
+            {
+               return reject(err);
+            }
+        });
+    }
+    
+    public override FileExists(file: string): Promise<boolean> {
+        return new Promise<boolean>(async (resolve, reject) => 
+        {           
+            try{
+
+                return resolve(File.existsSync(file) && File.lstatSync(file).isFile());
+
+            }catch(err)
+            {
+                return  reject(err);
+            }
+        });
+    }
+
+    public override DirectoryExists(path: string): Promise<boolean> {
+        return new Promise<boolean>(async (resolve, reject) => 
+        {            
+            try{
+                
+                return resolve(File.existsSync(path) && File.lstatSync(path).isDirectory());
+
+            }catch(err)
+            {
+                return  reject(err);
+            }
+        });
+    }
+
+    public override GetAllFiles(origin: string): Promise<string[]> {
+        
+        return new Promise<string[]>(async (resolve, reject) => 
+        {
+            if(!File.existsSync(origin))
+               return reject(new Error(`The path ${origin} not exists`));
+
+            try{
+
+            let files = await FileAsync.readdir(origin, {withFileTypes : true});
+
+            return resolve(files.filter(u => u.isFile()).map(u => Path.join(origin, u.name)));
+
+            }catch(err)
+            {
+                return  reject(err);
+            }
+        });
+    }
+
+    public override GetAllForders(origin: string): Promise<string[]> {
+
+        return new Promise<string[]>(async (resolve, reject) => 
+        {
+            if(!File.existsSync(origin))
+                return reject(new Error(`The path ${origin} not exists`));
+
+            try{
+
+            let files = await FileAsync.readdir(origin, {withFileTypes : true});           
+
+            return resolve(files.filter(u => u.isDirectory()).map(u => Path.join(origin, u.name)));
+
+            }catch(err)
+            {
+                return  reject(err);
+            }
+        });
+    }
+
+    public override CopyAsync(origin: string, dest: string): Promise<void> {
+     
+        return new Promise<void>(async (resolve, reject)=>
+        {
+            try{
+                await File.copyFile(origin, dest, (err) => 
+                {
+                    if(err) 
+                        throw err;
+
+                    resolve();
+                })
+
+            }catch(err)
+            {
+                reject(err);
+            }
+        })
+        
+    }
+    
+}
+

package/services/fileService/FileServiceBase.ts

@@ -0,0 +1,16 @@
+import { IDirectory } from "../../interfaces/entities/IDirectory";
+
+export default abstract class FileServiceBase 
+{
+    constructor(){}
+
+    public abstract CopyAsync(origin: string, dest: string): Promise<void>;
+    public abstract GetAllFiles(origin: string): Promise<string[]>;
+    public abstract GetAllForders(origin: string): Promise<string[]>;
+    public abstract FileExists(file: string): Promise<boolean>;
+    public abstract DirectoryExists(path: string): Promise<boolean>;
+    public abstract CreateDirectory(path: string): Promise<void>;
+    public abstract GetDefaultDir(): string;
+   
+}
+

package/tsconfig.json

@@ -0,0 +1,103 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+     "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
+     "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+     "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+     "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}