Overview

This page will cover the decorators, what they do and how to use them.

• Autoload
• Configure
• Controller
• Expose
• Hook
• Service
• Task
• Thread
• Worker

Autoload

The autoload decorator can help dictate the order in which modules are autowired, helpful for use cases where you may run into a race condition, as much as the framework is built around avoiding this by leveraging lazy loaded injections, etc. - It can still happen.

You can use the decorator like so:

Parameters

• priority - The priority in which the module should be loaded, the smaller the number, the higher the priority, we suggest keeping around 1 - 100.

@Autoload(priority: number)

Usage

import { Autoload } from '@sodacore/core';

@Autoload(1)
export class Something {}

Configure

The configure decorator adds additional user-defined meta data to a class.

Parameters

• config - The configuration object to be passed to the class.

@Configure(config: Record<string, any>)

Usage

import { Configure } from '@sodacore/core';
import { Utils } from '@sodacore/di';

@Configure
export class Something {

	public constructor() {
		const config = Utils.getMeta<Record<string, any>>('user', 'config')(this.constructor);
		console.log(config);
	}
}

Controller

The controller decorator is used to deal with threads that dispatch events back to the main thread.

Parameters

• namespace - The namespace of the controller.

@Controller(namespace: string)

Usage

import { Controller } from '@sodacore/core';

@Controller('something')
export class Something {}

See Threads for more information.

Expose

The expose decorator is used by the threads and workers to define which methods must be passed to the thread or worker respectively.

Parameters

@Expose()

Usage

import { Expose } from '@sodacore/core';

@Thread(/* options */)
export class Something {

	@Expose()
	public doSomething() {
		console.log('Something');
	}
}

Hook

The hook decorator allows you to add hook into framework events within any module within your platform.

Parameters

• event - The event to hook into, see below for event types.

@Hook(event: string)

Usage

import { Hook } from '@sodacore/core';
import { Provider } from '@sodacore/di';

@Provider()
export class Something {

	@Hook('preInit')
	public onPreInit() {
		console.log('Pre-Init');
	}
}

Events

Available events are:

Event Name	Description
preInit	This event is fired before the application is initialised.
postInit	This event is fired after the application is initialised.
preStart	This event is fired before the application is started.
postStart	This event is fired after the application is started.
preStop	This event is fired before the application is stopped.
postStop	This event is fired just before the application exits.

Service

The service decorator will mark a class as a service and that it will follow the service workflow.

Parameters

@Service()

Usage

import { Service } from '@sodacore/core';

@Service()
export class Something {}

Task

The task decorator denotes a class as a task and therefore should be loaded as a task.

Parameters

• schedule - The schedule in which the task should run, this is a cron string, i.e. * 4/ * * * * would run every 4 hours.
• settings - The settings for the task.
• settings.name - The name for the task.
• settings.maxRuns - Define the maximum number of runs for the task (defaults to infinity).
• settings.timezone - The timezone for the task (defaults to UTC).
• settings.startAt - Define the date and time this task should start from.
• settings.endAt - Define the date and time this task should end at.
• settings.interval - Define the interval in which the task should run. Docs Link
• settings.protect - Set to true or a callback to allow tasks to overrun the next run time. Docs Link

@Task(schedule?: string, settings?: ITaskSettings)

Usage

import { Task } from '@sodacore/core';

@Task('* 4/ * * * *')
export class Something {}

Thread

The thread decorator handles launching and offloading methods into a separate thread process.

Parameters

• filename - This is the filename of the file this is called from.
• flags - The flags to pass to the thread, these are essentially command line arguments.

@Thread(filename: string, flags?: Record<string, string | number>)

Usage

import { Thread, Utils, BaseThread } from '@sodacore/core';
import { Registry } from '@sodacore/registry';

@Thread(Utils.resolve(import.meta.filename, '../example.js'), () => ({
	httpConfig: Registry.get('@http:config'),
}))
export class SomeThread extends BaseThread {}

Worker

The worker decorator handles launching and offloading methods into a separate worker process.

Parameters

• filename - This is the filename of the file this is called from.

@Worker(filename: string)

Usage

import { Worker, Utils, Expose } from '@sodacore/core';

@Worker(Utils.getFilePath('../worker/example.ts'))
export class ExampleWorker {}