Merge pull request #16 from Prashant-Surya/feat/temporal-sdk-upgrade

Upgrade library to support temporal sdk v1.4.0

README.md

@@ -101,9 +101,48 @@ export class AppController {
 }
 ```
 
+## Advanced Options
+
+```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: [
+    TempModule.forRootAsync({
+      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 {
+          connection,
+          taskQueue: 'default',
+          workflowBundle,
+        };
+      },
+    }),
+  ],
+})
+export class AppModule {}
+```
+
 ## People
 
 - Author - [Zegue kurt](https://github.com/KurtzL)
+- Contributor - [Surya Prashanth](https://github.com/Prashant-Surya)
+- Contributor - [AmirSaber Sharifi](https://github.com/amirsaber)
+- Contributor - [J.D Nicholls](https://github.com/jdnichollsc)
 
 ## License
 

lib/decorators/activities.decorator.ts

@@ -1,8 +1,9 @@
 import { Scope, SetMetadata } from '@nestjs/common';
 import { SCOPE_OPTIONS_METADATA } from '@nestjs/common/constants';
-import { TEMPORAL_MODULE_ACTIVITIES } from '../temporal.constants';
 import { ActivityOptions } from '@temporalio/workflow';
 
+import { TEMPORAL_MODULE_ACTIVITIES } from '../temporal.constants';
+
 export interface ActivitiesOptions extends ActivityOptions {
   /**
    * Specifies the name of the queue to subscribe to.

lib/decorators/activity.decorator.ts

@@ -1,4 +1,5 @@
 import { SetMetadata } from '@nestjs/common';
+
 import { TEMPORAL_MODULE_ACTIVITY } from '../temporal.constants';
 
 export interface ActivityOptions {

lib/decorators/inject-temporal-client.decorator.ts

@@ -1,4 +1,5 @@
 import { Inject } from '@nestjs/common';
+
 import { getQueueToken } from '../utils';
 
 export const InjectTemporalClient = (name?: string): ParameterDecorator =>

lib/decorators/workflow.decorator.ts

@@ -1,4 +1,5 @@
 import { SetMetadata } from '@nestjs/common';
+
 import { TEMPORAL_MODULE_WORKFLOW_METHOD } from '../temporal.constants';
 
 export interface WorkflowMethodOptions {

lib/decorators/workflows.decorator.ts

@@ -1,5 +1,6 @@
 import { Scope, SetMetadata } from '@nestjs/common';
 import { SCOPE_OPTIONS_METADATA } from '@nestjs/common/constants';
+
 import { TEMPORAL_MODULE_WORKFLOW } from '../temporal.constants';
 
 export interface WorkflowsOptions {

lib/interfaces/index.ts

@@ -1,3 +1,5 @@
 export * from './temporal-module-options.interface';
-export * from './shared-temporal-config.interface';
+export * from './shared-worker-config.interface';
+export * from './shared-runtime-config.interface';
+export * from './shared-connection-config.interface';
 export * from './temporal-module.interface';

lib/interfaces/shared-connection-config.interface.ts

@@ -0,0 +1,26 @@
+import { FactoryProvider, ModuleMetadata, Type } from '@nestjs/common';
+import { NativeConnectionOptions } from '@temporalio/worker';
+
+export interface SharedConnectionConfigurationFactory {
+  createSharedConfiguration(): Promise<NativeConnectionOptions> | NativeConnectionOptions;
+}
+
+export interface SharedConnectionAsyncConfiguration
+  extends Pick<ModuleMetadata, 'imports'> {
+  /**
+   * Existing Provider to be used.
+   */
+  useExisting?: Type<SharedConnectionConfigurationFactory>;
+  /**
+   * Type (class name) of provider (instance to be registered and injected).
+   */
+  useClass?: Type<SharedConnectionConfigurationFactory>;
+  /**
+   * Factory function that returns an instance of the provider to be injected.
+   */
+  useFactory?: (...args: any[]) => Promise<NativeConnectionOptions> | NativeConnectionOptions;
+  /**
+   * Optional list of providers to be injected into the context of the Factory function.
+   */
+  inject?: FactoryProvider['inject'];
+}

lib/interfaces/shared-runtime-config.interface.ts

@@ -0,0 +1,26 @@
+import { FactoryProvider, ModuleMetadata, Type } from '@nestjs/common';
+import { RuntimeOptions } from '@temporalio/worker';
+
+export interface SharedRuntimeConfigurationFactory {
+  createSharedConfiguration(): Promise<RuntimeOptions> | RuntimeOptions;
+}
+
+export interface SharedRuntimeAsyncConfiguration
+  extends Pick<ModuleMetadata, 'imports'> {
+  /**
+   * Existing Provider to be used.
+   */
+  useExisting?: Type<SharedRuntimeConfigurationFactory>;
+  /**
+   * Type (class name) of provider (instance to be registered and injected).
+   */
+  useClass?: Type<SharedRuntimeConfigurationFactory>;
+  /**
+   * Factory function that returns an instance of the provider to be injected.
+   */
+  useFactory?: (...args: any[]) => Promise<RuntimeOptions> | RuntimeOptions;
+  /**
+   * Optional list of providers to be injected into the context of the Factory function.
+   */
+  inject?: FactoryProvider['inject'];
+}

lib/interfaces/temporal-module.interface.ts

@@ -1,6 +1,7 @@
 import { DynamicModule } from '@nestjs/common';
 import { WorkerOptions } from '@temporalio/worker';
-import { SharedWorkerAsyncConfiguration } from './shared-temporal-config.interface';
+
+import { SharedWorkerAsyncConfiguration } from './shared-worker-config.interface';
 import { TemporalModuleOptions } from './temporal-module-options.interface';
 
 export interface ITemporalModule {

lib/temporal-metadata.accessors.ts

@@ -1,5 +1,6 @@
 import { Injectable, Type } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
+
 import {
   TEMPORAL_MODULE_ACTIVITIES,
   TEMPORAL_MODULE_ACTIVITY,

lib/temporal.constants.ts

@@ -7,3 +7,4 @@ export const TEMPORAL_MODULE_WORKFLOW_METHOD =
 export const TEMPORAL_WORKER_CONFIG = '_temporal_worker_config';
 export const TEMPORAL_CORE_CONFIG = '_temporal_core_config';
 export const TEMPORAL_CLIENT_CONFIG = '_temporal_client_config';
+export const TEMPORAL_CONNECTION_CONFIG = '_temporal_connection_config';

lib/temporal.explorer.ts

@@ -1,26 +1,37 @@
 import {
   Injectable,
+  Logger,
   OnApplicationBootstrap,
   OnModuleDestroy,
   OnModuleInit,
 } from '@nestjs/common';
 import { DiscoveryService, MetadataScanner, ModuleRef } from '@nestjs/core';
 import { Injector } from '@nestjs/core/injector/injector';
 import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
-import { TemporalMetadataAccessor } from './temporal-metadata.accessors';
-import { Worker, WorkerOptions, Core, CoreOptions } from '@temporalio/worker';
-import { ActivityInterface } from '@temporalio/activity';
 import {
+  NativeConnection,
+  NativeConnectionOptions,
+  Runtime,
+  RuntimeOptions,
+  Worker,
+  WorkerOptions,
+} from '@temporalio/worker';
+
+import {
+  TEMPORAL_CONNECTION_CONFIG,
   TEMPORAL_CORE_CONFIG,
   TEMPORAL_WORKER_CONFIG,
 } from './temporal.constants';
+import { TemporalMetadataAccessor } from './temporal-metadata.accessors';
 
 @Injectable()
 export class TemporalExplorer
   implements OnModuleInit, OnModuleDestroy, OnApplicationBootstrap
 {
+  private readonly logger = new Logger(TemporalExplorer.name);
   private readonly injector = new Injector();
   private worker: Worker;
+  private timerId: ReturnType<typeof setInterval>;
 
   constructor(
     private readonly moduleRef: ModuleRef,
@@ -29,35 +40,55 @@ export class TemporalExplorer
     private readonly metadataScanner: MetadataScanner,
   ) {}
 
+  clearInterval() {
+    this.timerId && clearInterval(this.timerId);
+    this.timerId = null;
+  }
+
   async onModuleInit() {
     await this.explore();
   }
 
   onModuleDestroy() {
-    this.worker.shutdown();
+    this.worker?.shutdown();
+    this.clearInterval();
   }
 
   onApplicationBootstrap() {
-    setTimeout(() => {
-      this.worker.run();
+    this.timerId = setInterval(() => {
+      if (this.worker) {
+        this.worker.run();
+        this.clearInterval();
+      }
     }, 1000);
   }
 
   async explore() {
-    const workerConfig: WorkerOptions = this.getWorkerConfigOptions();
-    const coreConfig: CoreOptions = this.getCoreConfigOptions();
+    const workerConfig = this.getWorkerConfigOptions();
+    const runTimeOptions = this.getRuntimeOptions();
+    const connectionOptions = this.getNativeConnectionOptions();
 
     // should contain taskQueue
     if (workerConfig.taskQueue) {
-      const activitiesFunc: ActivityInterface = await this.handleActivities();
-
-      await Core.install(coreConfig);
-
+      const activitiesFunc = await this.handleActivities();
+
+      if (runTimeOptions) {
+        this.logger.verbose('Instantiating a new Core object');
+        Runtime.install(runTimeOptions);
+      }
+
+      const workerOptions = {
+        activities: activitiesFunc,
+      } as WorkerOptions;
+      if (connectionOptions) {
+        this.logger.verbose('Connecting to the Temporal server');
+        workerOptions.connection = await NativeConnection.connect(connectionOptions);
+      }
+
+      this.logger.verbose('Creating a new Worker');
       this.worker = await Worker.create(
         Object.assign(
-          {
-            activities: activitiesFunc,
-          },
+          workerOptions,
           workerConfig,
         ),
       );
@@ -70,16 +101,22 @@ export class TemporalExplorer
     });
   }
 
-  getCoreConfigOptions(name?: string): CoreOptions {
+  getNativeConnectionOptions(name?: string): NativeConnectionOptions {
+    return this.moduleRef.get(TEMPORAL_CONNECTION_CONFIG || name, {
+      strict: false,
+    });
+  }
+
+  getRuntimeOptions(name?: string): RuntimeOptions {
     return this.moduleRef.get(TEMPORAL_CORE_CONFIG || name, { strict: false });
   }
 
   /**
    *
    * @returns
    */
-  async handleActivities(): Promise<ActivityInterface> {
-    const activitiesMethod: ActivityInterface = {};
+  async handleActivities() {
+    const activitiesMethod = {};
 
     const activities: InstanceWrapper[] = this.discoveryService
       .getProviders()