Providers

Feature: Providers

A provider is a class of useful methods that can be shared between one or many controllers and services, they can be injected similar to a model.

1. Create the structure.
The below will create a new folder: ./src/provider and then create a new file inside.

mkdir ./src/provider
touch ./src/provider/logger.ts

2. Create the provider code.
The below is a simple example of creating a shared function that all controllers can use, I am going to use the built in logger class and use that, FYI this logger class is very basic at the moment and simply prints information, add the below into the new file.

// Import our package parts.
import { Provide, AbstractProvider, Logger } from 'rewyre';

// Worth noting we name the provider, then we also define it as `shared` which means, only one instance is created
// and then assigned to each class that wants it, otherwise if we use the `single` option it will create an instance
// per class that wants it, which is more expensive, but may be required if it is something like user management which
// shared instances could pose a security problem.
@Provide('logger', 'shared')
export class LoggerProvider extends AbstractProvider {

	protected logger: Logger;

	constructor() {
		this.logger = new Logger();
	}

	public notice(namespace: string, message: string): void {
		this.logger.notice(namespace, message);
	}

	public warn(namespace: string, message: string): void {
		this.logger.warn(namespace, message);
	}

	public error(namespace: string, message: string, err: Error): void {
		this.logger.error(namespace, message, err);
	}
}

3. Update the controller.
Below we are going to amend the ./src/controller/people.ts file, and we will log everytime a request for the list of people is processed.

import { Controller, Route, AbstractController, IReturn, IContext } from 'rewyre';
import { PeopleModel } from '../model/people';
import { LoggerProvider } from '../provider/logger';

// Here we are injecting the people model, this can also be an array of many injects.
@Inject(['people', 'logger'])
@Controller('/', 'people')
export class PeopleController extends AbstractController {

	private people!: PeopleModel;

	// We have creared 
	private logger!: LoggerProvider;

	@Route('GET', '/')
	public async list(context: IContext): Promise<IReturn> {
		this.logger.notice('PEOPLE:CONTROLLER', `Request was made for a list of people by IP: ${context.ipAddress}.`);
		const people: any = this.people.find({});
		return { status: 200, content: people };
	}

	@Route('POST', '/')
	public async create(context: IContext): Promise<IReturn> {
		await this.people.insertOne(context.body);
		return { status: 201 };
	}

	@Route('DELETE', '/:id')
	public async delete(context: IContext): Promise<IReturn> {
		await this.people.deleteOne({ _id: new ModelRecordID(context.params.id) });
		return { status: 204 };
	}

	@Route('GET', '/:id')
	public async get(context: IContext): Promise<IReturn> {
		const person: any = await this.tasks.findOne({ _id: new ModelRecordID(context.params.id) });
		return { status: 200, content: person };
	}
}

4. Register the provider.
So we have a provider, but we have not registered it, so let's go back to our ./src/application.ts file and register it.

import { Framework } from 'rewyre';
import { PeopleController } from '../controller/people';
import { PeopleModel } from '../model/people';

// Import the provider.
import { LoggerProvider } from '../provider/logger';

(async () => {

	const application: Framework = new Framework({
		port: 8080,
		database: true,
		databases: [
			{
				unique: 'main',
				host: 'localhost',
				port: 27017,
				name: 'demo-rewyre-app',
				driver: Drivers.MONGO,
				default: true,
			},
		],
	});

	// Register the class.
	application.register([ PeopleController, PeopleModel, LoggerProvider ]);

	await application.start();
});