NEXUS - HTTP2 Server Framework

• handle headers

  • @Headers headers: any -> headers.get() / headers.set() [etc.]

• publish to npm

  • https://zellwk.com/blog/publish-to-npm/
  • https://www.npmjs.com/package/np

Future

• define folder structure (clean up)
• optimize error messages
• add global namespace
• send file
• handle cors, checkout helmet for security (XSS)
• regex as route/ controller
• http 1 fallback
• web sockets

function map<T>(values: Partial<T>, ctor: new () => T): T {
	const instance = new ctor();

	for (const key in Object.keys(instance)) {
		const value: any = values[key];

		if (value === undefined) {
			throw new InvalidArguments('...');
		}

		instance[key] = value;
	}

	return instance;
}

• payload validator

@Controller
class ExampleController {
	@HttpPost('/:id', /^\d+$/)
	public async boo(@Body(() => ) body: any): Promise<Response> {
		return Ok({ value: 'marc' });
	}
}

• regex route support -> validators (length, characters, etc...)

openssl req -x509 -newkey rsa:2048 -nodes -sha256 -subj '/CN=localhost' -keyout key.pem -out cert.pem

• [ ] Framework
• [ ] Template (docker, kubernetees, github repository template, jest)
• [ ] Docusuarus [openSSL, ngrok?]
  • https://docusaurus.io/docs/deployment#deploying-to-github-pages
• [ ] CLI
• [ ] VS Code extension

@Middleware(...)
export class SecureMiddleware extends MiddlewareBase {
	public use() {
		//
	}
}

@Controller
@Use(SecureMiddleware)
export class ExampleController {
	// ...
}

Middleware

• RequestHandler
• MiddlewareFactory - rename

RequestHandler

function myMiddleware(serverRequest: Request, serverResponse: ServerResponse): void {
	console.log('Hello RequestHandler middleware');
}

@Use(myMiddleware)

Factory

function myMiddlewareFactory(greeting: string): void {
	return function (serverRequest: Request, serverResponse: ServerResponse): void {
		console.log(greeting);
	};
}

@Use(myMiddlewareFactory('Hello RequestHandler middleware factory'))

Overladed

function myOverloadedMiddleware(greeting: string): (serverRequest: Request, serverResponse: ServerResponse) => void;
function myOverloadedMiddleware(serverRequest: Request, serverResponse: ServerResponse): void;
function myOverloadedMiddleware(...args: any[]): void | ((serverRequest: Request, serverResponse: ServerResponse) => void) {

	function middlewareFactory(greeting: string): ((serverRequest: Request, serverResponse: ServerResponse) => void) {
		return function(serverRequest: Request, serverResponse: ServerResponse): void {
			console.log(greeting);
		}
	}

	if (args[0] instanceOf Request && args[1] instanceOf ServerResponse) {
		return middlewareFactory('default overload')
	}

	return middlewareFactory(args[0])
}

@Use(myOverloadedMiddleware) // logs 'default overload'
@Use(myOverloadedMiddleware('Hello RequestHandler middleware factory'))

MiddlewareFactory

class MyMiddleware extends MiddlewareFactory {
	public use(): void {
		console.log('Hello MiddlewareFactory middleware');
	}
}

@Use(MyMiddleware)

function myMiddlewareFactory(greeting: string): typeof MiddlewareFactory {
	class Logger extends MiddlewareFactory {
		public use(): void {
			console.log(greeting);
		}
	}

	return Logger;
}

@Use(myMiddlewareFactory('Hello MyMiddlewareFactory middleware'))

@Controller
@SetHeaders(options)
class ExampleController {
	@HttpGet
	@SetHeaders(options)
	public foo(): Response {
		const response: Response = Ok({...});
		response.setHeader(key, value);
		const values: any = response.getHeaders();
		const value: any = response.getHeader(key);
		const condition: boolean = response.hasHeader(key);
		return response;
	}

	@HttpGet
	@SetHeaders(options)
	public foo(): Response {
		const response: Response = Ok({...});
		response.setHeader(key, value);
		const values: any = response.getHeaders();
		const value: any = response.getHeader(key);
		const condition: boolean = response.hasHeader(key);
		return Ok({...})
	}
}