[circleci-image]: https://img.shields.io/circleci/build/github/nestjs/nest/master?token=abc123def456
[circleci-url]: https://circleci.com/gh/nestjs/nest

A progressive Node.js framework for building efficient and scalable server-side applications.

nestjs-temporal

Temporal module for Nest.

Requirements

- Node.js >= 12.0.0
- NestJS >= 8.0.0 (supports NestJS 8, 9, 10, and 11)

Quick start

``ts
import { Module } from '@nestjs/common';
import { TemporalModule } from 'nestjs-temporal';

@Module({
imports: [
TemporalModule.registerWorker({
workerOptions: {
taskQueue: 'default',
workflowsPath: require.resolve('./temporal/workflow'),
},
}),

TemporalModule.registerClient(),
],
})
export class AppModule {
}
`

`ts
import { Injectable } from '@nestjs/common';
import { Activities, Activity } from 'nestjs-temporal';

@Injectable()
@Activities()
export class GreetingActivity {
constructor() {}

@Activity()
async greeting(name: string): Promise {
return 'Hello ' + name;
}
}

export interface IGreetingActivity {
greeting(name: string): Promise;
}
`

`ts
import { proxyActivities } from '@temporalio/workflow';
// Only import the activity types
import { IGreetingActivity } from '../activities';

const { greeting } = proxyActivities({
startToCloseTimeout: '1 minute',
});

export async function example(name: string): Promise {
return await greeting(name);
}
`

`ts
import { Controller, Post } from '@nestjs/common';
import { Connection, WorkflowClient } from '@temporalio/client';
import { InjectTemporalClient } from 'nestjs-temporal';

@Controller()
export class AppController {
constructor(
@InjectTemporalClient() private readonly temporalClient: WorkflowClient,
) {}

@Post()
async greeting() {
const handle = await this.temporalClient.start('example', {
args: ['Temporal'],
taskQueue: 'default',
workflowId: 'wf-id-' + Math.floor(Math.random() * 1000),
});
console.log(Started workflow ${handle.workflowId});
}
}
`

Advanced Options

- Creating the Worker connection:
`ts
import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { TemporalModule } from 'nestjs-temporal';
import { bundleWorkflowCode, NativeConnection, Runtime } from '@temporalio/worker';
import * as path from 'path';

@Module({
imports: [
TemporalModule.registerWorkerAsync({
imports: [ConfigModule],
inject: [ConfigService],
useFactory: async (config: ConfigService) => {
Runtime.install({});
const temporalHost = config.get('app.temporalHost');
const connection = await NativeConnection.connect({
address: temporalHost,
});
const workflowBundle = await bundleWorkflowCode({
workflowsPath: path.join(__dirname, './workflows'),
});

return {
workerOptions: {
connection,
taskQueue: 'default',
workflowBundle,
}
};
},
}),
ClientModule,
],
})
export class AppModule {}
`

- Creating the client connection:
`ts
import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { TemporalModule } from 'nestjs-temporal';
import { Connection } from '@temporalio/client';

@Module({
imports: [
TempModule.registerClientAsync({
imports: [ConfigModule],
inject: [ConfigService],
useFactory: async (config: ConfigService) => {
const temporalHost = config.get('app.temporalHost');
const connection = await Connection.connect({
address: temporalHost,
});

return {
connection,
};
},
}),
],
})
export class ClientModule {}
`


Multiple workers

Multiple workers can be registered by making multiple calls to TemporalModule.registerWorker or
TemporalModule.registerWorkerAsync.

You must explicitly specify your activity classes when registering multiple workers; otherwise, the workers may
register all activities marked by @Activity(). You may find it more convenient to import dynamic worker module into
the module that actually contains the workflow and activities rather than your root AppModule.

`ts
// Register the client once at the app level
import { Module } from '@nestjs/common';
import { TemporalModule } from 'nestjs-temporal';

@Module({
imports: [
TemporalModule.registerClient(),
],
})
export class AppModule {
}

// Configure Worker #1
@Module({
imports: [
TemporalModule.registerWorker({
workerOptions: {
taskQueue: 'worker-1',
workflowsPath: require.resolve('./temporal/workflow-1'),
},
activityClasses: [Greeting1Activity],
}),
],
providers: [Greeting1Activity],
})
export class Worker1Module {
}

// Configure Worker #2
@Module({
imports: [
TemporalModule.registerWorker({
workerOptions: {
taskQueue: 'worker-2',
workflowsPath: require.resolve('./temporal/workflow-2'),
},
activityClasses: [SomeOtherActivity],
}),
],
providers: [SomeOtherActivity],
})
export class Worker2Module {
}
``

People

- Author - Zegue kurt
- Contributor - Surya Prashanth
- Contributor - AmirSaber Sharifi
- Contributor - J.D Nicholls
- Contributor - Clinton Blackburn

License

Nest is MIT licensed.