### Register Default Local Temporal Client

Source: https://context7.com/kurtzl/nestjs-temporal/llms.txt

Use `TemporalModule.registerClient()` without arguments to connect to the default local Temporal server at `localhost:7233`. This is the simplest way to get started.

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

@Module({
  imports: [
    // Default: connects to localhost:7233
    TemporalModule.registerClient(),

    // With explicit connection options:
    // TemporalModule.registerClient({
    //   connection: { address: 'temporal.example.com:7233' },
    //   workflowOptions: { namespace: 'production' },
    // }),
  ],
})
export class AppModule {}
```

--------------------------------

### Valid Commit Message Examples

Source: https://github.com/kurtzl/nestjs-temporal/blob/main/CONTRIBUTING.md

Examples of valid commit messages adhering to the Conventional Commits format, including different types and scopes.

```markdown
fix: resolve worker shutdown issue
feat: add support for multiple workers
docs: update README with usage examples
refactor: improve type safety in TemporalExplorer
fix(worker): handle connection errors gracefully
feat(client): add named client support

docs: add comprehensive JSDoc documentation

This commit adds JSDoc comments to all public APIs
to improve code documentation and IDE support.
```

--------------------------------

### Register Temporal Worker Async

Source: https://github.com/kurtzl/nestjs-temporal/blob/main/README.md

Configure a Temporal worker connection asynchronously. Requires ConfigModule for environment variables and installs the Temporal Runtime.

```typescript
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 {}
```

--------------------------------

### Start a Temporal Workflow from a NestJS Controller

Source: https://github.com/kurtzl/nestjs-temporal/blob/main/README.md

Inject the Temporal client into a NestJS controller using @InjectTemporalClient(). Use the client to start a workflow, providing its name, arguments, task queue, and a unique workflow ID.

```typescript
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}`);
  }
}
```

--------------------------------

### Invalid Commit Message Examples

Source: https://github.com/kurtzl/nestjs-temporal/blob/main/CONTRIBUTING.md

Examples of invalid commit messages that violate the Conventional Commits specification, highlighting common errors.

```markdown
INVALID: test message                    # Type must be lowercase
fix:                                    # Description is required
Fix: resolve issue                      # Type must be lowercase
fix: Resolve issue.                     # Description ends with period
feat: Add new feature                   # Description should be lowercase
invalid-type: test message              # Type not in allowed list
```

--------------------------------

### Synchronous Worker Registration with NestJS Temporal

Source: https://context7.com/kurtzl/nestjs-temporal/llms.txt

Use `TemporalModule.registerWorker()` for synchronous setup. Configure `workerOptions`, `activityClasses` to restrict activities, and `errorOnDuplicateActivities` to catch naming conflicts.

```typescript
import {
  Module
} from '@nestjs/common';
import {
  TemporalModule
} from 'nestjs-temporal';
import {
  GreetingActivities
} from './activities/greeting.activities';

@Module({
  imports: [
    TemporalModule.registerWorker({
      workerOptions: {
        taskQueue: 'default',
        workflowsPath: require.resolve('./workflows'),
      },
      // Optional: restrict to specific activity classes (needed for multiple workers)
      activityClasses: [GreetingActivities],
      // Optional: throw if duplicate activity method names are found
      errorOnDuplicateActivities: true,
    }),
  ],
  providers: [GreetingActivities],
})
export class AppModule {}
```

--------------------------------

### Register Multiple Temporal Workers

Source: https://github.com/kurtzl/nestjs-temporal/blob/main/README.md

Example of registering multiple Temporal workers with distinct task queues and activity classes. The client is registered once at the app level.

```typescript
// 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 {
}
```

--------------------------------

### @InjectTemporalClient Decorator

Source: https://context7.com/kurtzl/nestjs-temporal/llms.txt

Injects a WorkflowClient registered via TemporalModule.registerClient() or registerClientAsync(). Use the injected client to start, signal, query, or cancel workflow executions.

```APIDOC
## @InjectTemporalClient(name?)

Injects a `WorkflowClient` registered via `TemporalModule.registerClient()` or `registerClientAsync()`. Without arguments, injects the default (unnamed) client. Pass a name string to inject a named client registered with `{ name: 'my-client' }`. Use the injected client to start, signal, query, or cancel workflow executions.

```typescript
// workflow-starter.service.ts
import { Injectable } from '@nestjs/common';
import { WorkflowClient } from '@temporalio/client';
import { InjectTemporalClient } from 'nestjs-temporal';

@Injectable()
export class WorkflowStarterService {
  constructor(
    // Inject default client
    @InjectTemporalClient() private readonly client: WorkflowClient,
    // Inject named client (registered with name: 'reporting')
    @InjectTemporalClient('reporting') private readonly reportingClient: WorkflowClient,
  ) {}

  async triggerOnboarding(userId: string): Promise<void> {
    const handle = await this.client.start('onboardingWorkflow', {
      args: [{ userId }],
      taskQueue: 'default',
      workflowId: `onboarding-${userId}`,
      workflowExecutionTimeout: '7 days',
    });
    console.log(`Started onboarding workflow: ${handle.workflowId}`);
  }

  async cancelWorkflow(workflowId: string): Promise<void> {
    const handle = this.client.getHandle(workflowId);
    await handle.cancel();
  }

  async generateReport(reportId: string): Promise<string> {
    const handle = await this.reportingClient.start('generateReport', {
      args: [reportId],
      taskQueue: 'reports',
      workflowId: `report-${reportId}`,
    });
    return handle.result<string>();
  }
}
```
```

--------------------------------

### Inject and Use WorkflowClient in NestJS Service

Source: https://context7.com/kurtzl/nestjs-temporal/llms.txt

Inject the `WorkflowClient` into your NestJS services using `@InjectTemporalClient()` to start and manage Temporal workflows. Ensure the client is registered in a module.

```typescript
import {
  Injectable
} from '@nestjs/common';
import {
  WorkflowClient
} from '@temporalio/client';
import {
  InjectTemporalClient
} from 'nestjs-temporal';

@Injectable()
export class OrderService {
  constructor(
    @InjectTemporalClient() private readonly temporalClient: WorkflowClient,
  ) {}

  async startOrderWorkflow(orderId: string): Promise<string> {
    const handle = await this.temporalClient.start('processOrder', {
      args: [orderId],
      taskQueue: 'default',
      workflowId: `order-${orderId}`,
    });
    return handle.workflowId;
  }

  async getOrderStatus(workflowId: string): Promise<string> {
    const handle = this.temporalClient.getHandle(workflowId);
    return handle.result(); // waits for completion
  }
}
```

--------------------------------

### Running Tests

Source: https://github.com/kurtzl/nestjs-temporal/blob/main/CONTRIBUTING.md

Execute all project tests using npm.

```bash
npm test
```

--------------------------------

### Formatting Code

Source: https://github.com/kurtzl/nestjs-temporal/blob/main/CONTRIBUTING.md

Format the code according to project standards using npm.

```bash
npm run format
```

--------------------------------

### Running Linter

Source: https://github.com/kurtzl/nestjs-temporal/blob/main/CONTRIBUTING.md

Check code against linting rules using npm.

```bash
npm run lint
```

--------------------------------

### Register Temporal Client Async

Source: https://github.com/kurtzl/nestjs-temporal/blob/main/README.md

Configure a Temporal client connection asynchronously. Requires ConfigModule for environment variables.

```typescript
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 {}
```

--------------------------------

### Async Temporal Client Registration with Configuration

Source: https://context7.com/kurtzl/nestjs-temporal/llms.txt

Register the `WorkflowClient` asynchronously using `TemporalModule.registerClientAsync`. This is useful for loading configuration, secrets, or TLS certificates from external sources. Supports `useFactory`, `useClass`, `useExisting`, and `useValue`.

```typescript
import {
  Module
} from '@nestjs/common';
import {
  ConfigModule,
  ConfigService
} from '@nestjs/config';
import {
  TemporalModule
} from 'nestjs-temporal';
import {
  Connection
} from '@temporalio/client';

@Module({
  imports: [
    TemporalModule.registerClientAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      useFactory: async (config: ConfigService) => {
        const connection = await Connection.connect({
          address: config.get<string>('TEMPORAL_ADDRESS', 'localhost:7233'),
          tls: config.get<boolean>('TEMPORAL_TLS')
            ? {
                serverNameOverride: config.get('TEMPORAL_HOST')
              }
            : undefined,
        });
        return {
          connection,
          namespace: config.get('TEMPORAL_NAMESPACE')
        };
      },
    }),
  ],
  exports: [TemporalModule],
})
export class ClientModule {}
```

--------------------------------

### TemporalModule.registerClient

Source: https://context7.com/kurtzl/nestjs-temporal/llms.txt

Registers a global WorkflowClient provider synchronously. By default, it connects to localhost:7233. Options can be provided to specify connection details and workflow options, and multiple named clients can be registered.

```APIDOC
## `TemporalModule.registerClient(options?)` — Synchronous client registration

Registers a global `WorkflowClient` provider. When called without arguments the client connects to `localhost:7233`. Pass `connection` (`ConnectionOptions`) and/or `workflowOptions` (`WorkflowClientOptions`) to connect to a remote Temporal server or customise the client. Multiple named clients can be registered by passing `name`. The client is automatically closed on application shutdown.

```typescript
// app.module.ts — default local client
import { Module } from '@nestjs/common';
import { TemporalModule } from 'nestjs-temporal';

@Module({
  imports: [
    // Default: connects to localhost:7233
    TemporalModule.registerClient(),

    // With explicit connection options:
    // TemporalModule.registerClient({
    //   connection: { address: 'temporal.example.com:7233' },
    //   workflowOptions: { namespace: 'production' },
    // }),
  ],
})
export class AppModule {}

// order.service.ts — injecting and using the client
import { Injectable } from '@nestjs/common';
import { WorkflowClient } from '@temporalio/client';
import { InjectTemporalClient } from 'nestjs-temporal';

@Injectable()
export class OrderService {
  constructor(
    @InjectTemporalClient() private readonly temporalClient: WorkflowClient,
  ) {}

  async startOrderWorkflow(orderId: string): Promise<string> {
    const handle = await this.temporalClient.start('processOrder', {
      args: [orderId],
      taskQueue: 'default',
      workflowId: `order-${orderId}`,
    });
    return handle.workflowId;
  }

  async getOrderStatus(workflowId: string): Promise<string> {
    const handle = this.temporalClient.getHandle(workflowId);
    return handle.result(); // waits for completion
  }
}
```
```

--------------------------------

### Define a Temporal Workflow Method

Source: https://context7.com/kurtzl/nestjs-temporal/llms.txt

This code defines a workflow entry point using `@WorkflowMethod()` and demonstrates calling proxied activities and using durable timers within the Temporal sandbox. Workflow code runs in a sandboxed V8 isolate and cannot directly use NestJS DI.

```typescript
// order.workflow.ts — runs in Temporal sandbox (no DI)
import { proxyActivities, sleep } from '@temporalio/workflow';
import type { OrderActivities } from './order.activities';

const { processPayment, sendConfirmationEmail, shipOrder } = 
  proxyActivities<OrderActivities>({
    startToCloseTimeout: '5 minutes',
    retry: { maximumAttempts: 3 },
  });

export async function processOrder(orderId: string): Promise<string> {
  const transactionId = await processPayment(orderId);
  await sendConfirmationEmail(orderId);
  await sleep('1 hour'); // durable timer — survives worker restarts
  await shipOrder(orderId);
  return transactionId;
}
```

--------------------------------

### TemporalModule.registerClientAsync

Source: https://context7.com/kurtzl/nestjs-temporal/llms.txt

Registers a WorkflowClient asynchronously, allowing connection parameters to be resolved from async providers. This is useful for configurations that require asynchronous operations, such as reading from a vault or TLS certificates. It supports various provider strategies like `useFactory`, `useClass`, `useExisting`, and `useValue`, and allows for multiple named clients.

```APIDOC
## `TemporalModule.registerClientAsync(options)` — Async client registration

Registers a `WorkflowClient` asynchronously, resolving connection parameters from async providers. Useful for reading TLS certificates, secrets from a vault, or any async configuration source. Supports `useFactory`, `useClass`, `useExisting`, and `useValue`. The `name` field enables registering multiple named clients.

```typescript
// client.module.ts
import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { TemporalModule } from 'nestjs-temporal';
import { Connection } from '@temporalio/client';

@Module({
  imports: [
    TemporalModule.registerClientAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      useFactory: async (config: ConfigService) => {
        const connection = await Connection.connect({
          address: config.get<string>('TEMPORAL_ADDRESS', 'localhost:7233'),
          tls: config.get<boolean>('TEMPORAL_TLS')
            ? { serverNameOverride: config.get('TEMPORAL_HOST') }
            : undefined,
        });
        return { connection, namespace: config.get('TEMPORAL_NAMESPACE') };
      },
    }),
  ],
  exports: [TemporalModule],
})
export class ClientModule {}
```
```

--------------------------------

### Implement a Temporal Workflow

Source: https://github.com/kurtzl/nestjs-temporal/blob/main/README.md

Define a Temporal workflow using TypeScript. Import and proxy activities using proxyActivities, specifying their types and timeouts. The workflow function orchestrates the execution of these activities.

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

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

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

--------------------------------

### Asynchronous Worker Registration with NestJS Temporal

Source: https://context7.com/kurtzl/nestjs-temporal/llms.txt

Employ `TemporalModule.registerWorkerAsync()` for configurations requiring async providers like `ConfigService`. The `useFactory` function can inject dependencies and return worker options.

```typescript
import {
  Module
} from '@nestjs/common';
import {
  ConfigModule,
  ConfigService
} from '@nestjs/config';
import {
  TemporalModule
} from 'nestjs-temporal';
import {
  NativeConnection,
  Runtime,
  bundleWorkflowCode
} from '@temporalio/worker';
import * as path from 'path';

@Module({
  imports: [
    ConfigModule.forRoot(),
    TemporalModule.registerWorkerAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      useFactory: async (config: ConfigService) => {
        Runtime.install({});
        const connection = await NativeConnection.connect({
          address: config.get<string>('TEMPORAL_ADDRESS', 'localhost:7233'),
        });
        const workflowBundle = await bundleWorkflowCode({
          workflowsPath: path.join(__dirname, './workflows'),
        });
        return {
          workerOptions: {
            connection,
            taskQueue: config.get<string>('TEMPORAL_TASK_QUEUE', 'default'),
            workflowBundle,
          },
        };
      },
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### Conventional Commits Format

Source: https://github.com/kurtzl/nestjs-temporal/blob/main/CONTRIBUTING.md

All commit messages must follow the Conventional Commits specification, including type, optional scope, description, and optional body/footers.

```markdown
<type>[optional scope]: <description>

[optional body]

[optional footer(s)]
```

--------------------------------

### Define a Temporal Activity in NestJS

Source: https://github.com/kurtzl/nestjs-temporal/blob/main/README.md

Create a NestJS injectable class decorated with @Activities() to define Temporal activities. Use the @Activity() decorator for each method that represents an activity.

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

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

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

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

--------------------------------

### Register Temporal Worker and Client in NestJS Module

Source: https://github.com/kurtzl/nestjs-temporal/blob/main/README.md

Configure the Temporal worker and client within your NestJS application's AppModule. Ensure the worker options, including task queue and workflow paths, are correctly set.

```typescript
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 {
}
```

--------------------------------

### @Activity Decorator

Source: https://context7.com/kurtzl/nestjs-temporal/llms.txt

Marks a method inside an @Activities() class as a Temporal activity. The method name is used as the activity name by default, but a custom name can be provided.

```APIDOC
## @Activity(nameOrOptions?)

Marks a method inside an `@Activities()` class as a Temporal activity. By default, the method name is used as the activity name. Pass a string or `ActivityOptions` object to use a custom name. The method is bound to its class instance, so constructor-injected dependencies (e.g., database clients) are fully available at execution time.

```typescript
// payment.activities.ts
import { Injectable } from '@nestjs/common';
import { Activities, Activity } from 'nestjs-temporal';
import { PaymentService } from '../payment/payment.service';

@Injectable()
@Activities()
export class PaymentActivities {
  constructor(private readonly paymentService: PaymentService) {}

  // Activity name = method name: "chargeCard"
  @Activity()
  async chargeCard(amount: number, cardToken: string): Promise<string> {
    const result = await this.paymentService.charge(amount, cardToken);
    return result.transactionId;
  }

  // Activity name explicitly set to "refund-payment"
  @Activity({ name: 'refund-payment' })
  async refundPayment(transactionId: string): Promise<void> {
    await this.paymentService.refund(transactionId);
  }
}
```
```

--------------------------------

### Define Temporal Activities with @Activity Decorator

Source: https://context7.com/kurtzl/nestjs-temporal/llms.txt

Use the `@Activity` decorator to mark methods within an `@Activities` class as Temporal activities. The method name defaults to the activity name, but can be customized using an `ActivityOptions` object. Injected dependencies are available at runtime.

```typescript
import {
  Injectable,
} from '@nestjs/common';
import {
  Activities,
  Activity,
} from 'nestjs-temporal';
import { PaymentService } from '../payment/payment.service';

@Injectable()
@Activities()
export class PaymentActivities {
  constructor(private readonly paymentService: PaymentService) {}

  // Activity name = method name: "chargeCard"
  @Activity()
  async chargeCard(amount: number, cardToken: string): Promise<string> {
    const result = await this.paymentService.charge(amount, cardToken);
    return result.transactionId;
  }

  // Activity name explicitly set to "refund-payment"
  @Activity({ name: 'refund-payment' })
  async refundPayment(transactionId: string): Promise<void> {
    await this.paymentService.refund(transactionId);
  }
}
```

--------------------------------

### Configure Multiple Temporal Workers in NestJS

Source: https://context7.com/kurtzl/nestjs-temporal/llms.txt

Register multiple workers by calling `TemporalModule.registerWorker` multiple times, each with a unique `taskQueue` and `activityClasses`. The `TemporalModule.registerClient` should be called once in the root `AppModule`.

```typescript
import { Module } from '@nestjs/common';
import { TemporalModule } from 'nestjs-temporal';
import { OrderActivities } from './order/order.activities';
import { ShippingActivities } from './shipping/shipping.activities';

@Module({
  imports: [
    // Single shared client at the app level
    TemporalModule.registerClient(),
    OrderModule,
    ShippingModule,
  ],
})
export class AppModule {}

// order.module.ts — Worker #1
@Module({
  imports: [
    TemporalModule.registerWorker({
      workerOptions: {
        taskQueue: 'orders',
        workflowsPath: require.resolve('./order.workflow'),
      },
      activityClasses: [OrderActivities],
      errorOnDuplicateActivities: true,
    }),
  ],
  providers: [OrderActivities],
})
export class OrderModule {}

// shipping.module.ts — Worker #2
@Module({
  imports: [
    TemporalModule.registerWorker({
      workerOptions: {
        taskQueue: 'shipping',
        workflowsPath: require.resolve('./shipping.workflow'),
      },
      activityClasses: [ShippingActivities],
      errorOnDuplicateActivities: true,
    }),
  ],
  providers: [ShippingActivities],
})
export class ShippingModule {}

```

--------------------------------

### Inject WorkflowClient with @InjectTemporalClient Decorator

Source: https://context7.com/kurtzl/nestjs-temporal/llms.txt

Use the `@InjectTemporalClient` decorator to inject a `WorkflowClient` instance. Inject the default client without arguments, or a named client by passing its registration name. This client is used to manage workflow executions.

```typescript
import {
  Injectable,
} from '@nestjs/common';
import { WorkflowClient } from '@temporalio/client';
import { InjectTemporalClient } from 'nestjs-temporal';

@Injectable()
export class WorkflowStarterService {
  constructor(
    // Inject default client
    @InjectTemporalClient() private readonly client: WorkflowClient,
    // Inject named client (registered with name: 'reporting')
    @InjectTemporalClient('reporting') private readonly reportingClient: WorkflowClient,
  ) {}

  async triggerOnboarding(userId: string): Promise<void> {
    const handle = await this.client.start('onboardingWorkflow', {
      args: [{ userId }],
      taskQueue: 'default',
      workflowId: `onboarding-${userId}`,
      workflowExecutionTimeout: '7 days',
    });
    console.log(`Started onboarding workflow: ${handle.workflowId}`);
  }

  async cancelWorkflow(workflowId: string): Promise<void> {
    const handle = this.client.getHandle(workflowId);
    await handle.cancel();
  }

  async generateReport(reportId: string): Promise<string> {
    const handle = await this.reportingClient.start('generateReport', {
      args: [reportId],
      taskQueue: 'reports',
      workflowId: `report-${reportId}`,
    });
    return handle.result<string>();
  }
}
```

--------------------------------

### Update NestJS Dependencies for v2.1.0

Source: https://github.com/kurtzl/nestjs-temporal/blob/main/RELEASE_NOTES.md

Use this command to update your NestJS dependencies to the latest stable version compatible with this release. Ensure you are using NestJS 11.

```bash
npm install @nestjs/common@^11.0.0 @nestjs/core@^11.0.0
```

--------------------------------

### Activities Decorator

Source: https://context7.com/kurtzl/nestjs-temporal/llms.txt

The `@Activities()` decorator is used on NestJS provider classes to mark them as containers for Temporal activities. It can optionally accept a queue name or an `ActivitiesOptions` object to configure activities. Methods within these classes decorated with `@Activity()` are automatically discovered and registered with the Temporal worker.

```APIDOC
## `@Activities()` — Class decorator for activity containers

Marks a NestJS provider class as a container for Temporal activities. The optional argument can be a queue name string or an `ActivitiesOptions` object (which also accepts Temporal `ActivityOptions` fields such as `startToCloseTimeout`). All methods in the class that are decorated with `@Activity()` will be automatically discovered and registered with the worker.

```typescript
// email.activities.ts
import { Injectable } from '@nestjs/common';
import { Activities, Activity } from 'nestjs-temporal';
import { MailService } from '../mail/mail.service';

@Injectable()
@Activities() // or @Activities('email-queue') to pin to a specific task queue
export class EmailActivities {
  constructor(private readonly mailService: MailService) {}

  @Activity()
  async sendWelcomeEmail(userId: string): Promise<void> {
    await this.mailService.send({
      to: userId,
      subject: 'Welcome!',
      template: 'welcome',
    });
  }

  @Activity('send-notification') // custom activity name
  async notify(payload: { userId: string; message: string }): Promise<boolean> {
    return this.mailService.sendNotification(payload);
  }
}

// Export interface for use in workflow (type-only import)
export interface IEmailActivities {
  sendWelcomeEmail(userId: string): Promise<void>;
  notify(payload: { userId: string; message: string }): Promise<boolean>;
}
```
```

--------------------------------

### Bypass Git Commit Hook

Source: https://github.com/kurtzl/nestjs-temporal/blob/main/CONTRIBUTING.md

Use this command to bypass the commit message validation hook when absolutely necessary, though it is not recommended for normal workflow.

```bash
git commit --no-verify -m "your message"
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.