@goparrot/temporal-sdk v1.0.0

temporal-sdk

Description

Temporal module for Nest.

Installation

npm i --save \
    @goparrot/temporal-sdk \
    @temporalio/activity \
    @temporalio/client \
    @temporalio/common \
    @temporalio/worker \
    @temporalio/workflow

npm i --save-optional \
    @swc/core-darwin-arm64 \
    @swc/core-linux-arm-gnueabihf \
    @swc/core-linux-arm64-gnu \
    @swc/core-linux-arm64-musl \
    @swc/core-linux-musl \
    @swc/core-linux-x64-gnu \
    @swc/core-linux-x64-musl

Create an activity:

import { Activities, Activity } from '@goparrot/temporal-sdk/worker';

@Activities()
export class GreetingsActivities {
    @Activity()
    async sayHelloActivity(name: string): Promise<string> {
        return `Hello ${name}!`;
    }
}

Create Temporal workflow:

import { proxyActivities } from "@temporalio/workflow";
import { TemporalActivities } from "../temporal-worker-app.module";

const { sayHelloActivity } = proxyActivities<TemporalActivities>({
  startToCloseTimeout: "1 minute",
});

export async function sayHelloWorkflow(name: string): Promise<string> {
  return sayHelloActivity(name);
}

Create Temporal worker module:

import { Module } from "@nestjs/common";
import { ConfigModule, ConfigService } from "@nestjs/config";
import { ITemporalWorkerModuleOptions, TemporalWorkerModule } from "@goparrot/temporal-sdk/worker";
import { NativeConnection } from "@temporalio/worker";

export const temporalActivities = [GreetingsActivities];

export type TemporalActivities = MergeActivities<typeof temporalActivities>;

@Module({
  imports: [
    ConfigModule.forRoot(),
    TemporalWorkerModule.registerAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService): Promise<ITemporalWorkerModuleOptions> => {
        const connection = await NativeConnection.connect({
          address: configService.getOrThrow("TEMPORAL_URL"),
        });

        return {
          workerOptions: {
            taskQueue: configService.getOrThrow("TEMPORAL_TASK_QUEUE"),
            connection,
            workflowsPath: require.resolve("./temporal-workflows"),
          },
          activityClasses: temporalActivities,
        };
      },
      inject: [ConfigService],
    }),
    GreetingsModule,
  ],
  controllers: [],
  providers: [],
})
export class TemporalWorkerAppModule {}

Create Temporal worker application entry file:

import { NestFactory } from "@nestjs/core";
import { TemporalWorkerAppModule } from "./temporal-worker-app.module";

async function bootstrap() {
  const app = await NestFactory.createApplicationContext(TemporalWorkerAppModule);
  await app.init();
}

bootstrap();

Import the Temporal client module

import { Module } from "@nestjs/common";
import { GreetingsModule } from "./greetings/greetings.module";
import { ITemporalClientModuleOptions, TemporalClientModule } from "@goparrot/temporal-sdk/client";
import { ConfigModule, ConfigService } from "@nestjs/config";
import { Connection } from "@temporalio/client";

@Module({
  imports: [
    ConfigModule.forRoot(),
    TemporalClientModule.registerAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService): Promise<ITemporalClientModuleOptions> => {
        return {
          workflowClientOptions: {
            connection: await Connection.connect({
              address: configService.getOrThrow("TEMPORAL_URL"),
            }),
          },
        };
      },
      inject: [ConfigService],
    }),
    GreetingsModule,
  ],
  controllers: [],
  providers: [],
})
export class AppModule {}

Inject the workflow client and execute the workflow

import { Controller, DefaultValuePipe, Get, Query } from "@nestjs/common";
import { WorkflowClient } from "@temporalio/client";
import { sayHelloWorkflow } from "../temporal-workflows";
import { ConfigService } from "@nestjs/config";
import { uid } from "uid";

@Controller("greetings")
export class GreetingsController {
  constructor(
    private readonly workflowClient: WorkflowClient,
    private readonly configService: ConfigService,
  ) {}

  @Get()
  async sayHello(@Query("name", new DefaultValuePipe("World")) name: string) {
    return this.workflowClient.execute(sayHelloWorkflow, {
      taskQueue: this.configService.getOrThrow("TEMPORAL_TASK_QUEUE"),
      workflowId: uid(),
      args: [name],
    });
  }
}