nestjs-temporal-core 2.0.8 → 3.0.0

package/README.md

@@ -1,49 +1,60 @@
 # NestJS Temporal Core
 
-A simplified NestJS integration for [Temporal.io](https://temporal.io/) that provides seamless worker and client support for building reliable distributed applications.
+A comprehensive NestJS integration for [Temporal.io](https://temporal.io/) that provides seamless worker and client support with auto-discovery, declarative scheduling, and enterprise-ready features for building reliable distributed applications.
+
+[![npm version](https://badge.fury.io/js/nestjs-temporal-core.svg)](https://badge.fury.io/js/nestjs-temporal-core)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/%3C%2F%3E-TypeScript-%230074c1.svg)](http://www.typescriptlang.org/)
+
+## 📚 Documentation
+
+### Quick Links
+- **[🚀 Getting Started](./docs/getting-started.md)** - Installation, basic setup, and first workflow
+- **[⚙️ Configuration](./docs/configuration.md)** - Complete configuration reference and examples
+- **[📖 API Reference](./docs/api-reference.md)** - Detailed API documentation for all services and decorators
+- **[🍳 Examples & Recipes](./docs/examples.md)** - Practical examples and common patterns
+- **[🏗️ Best Practices](./docs/best-practices.md)** - Production guidelines and optimization tips
+- **[🔄 Migration Guide](./docs/migration.md)** - Upgrading from previous versions
+- **[🔧 Troubleshooting](./docs/troubleshooting.md)** - Common issues and solutions
+
+### Advanced Topics
+- **[🏢 Enterprise Features](./docs/enterprise.md)** - Advanced features for production deployments
+- **[📊 Monitoring & Health](./docs/monitoring.md)** - Health checks, metrics, and observability
+- **[🔐 Security](./docs/security.md)** - TLS, authentication, and security best practices
+- **[🧪 Testing](./docs/testing.md)** - Testing workflows and activities
+- **[🐳 Deployment](./docs/deployment.md)** - Docker, Kubernetes, and cloud deployment guides
 
 ## Overview
 
-NestJS Temporal Core makes it easy to integrate Temporal.io with your NestJS applications. Temporal is a durable execution system for reliable microservices and workflow orchestration.
+NestJS Temporal Core makes it easy to integrate Temporal.io with your NestJS applications using familiar decorator patterns. Temporal is a durable execution system for reliable microservices and workflow orchestration.
 
-## Features
+## ✨ Features
 
 - 🚀 **Easy NestJS Integration** - Simple module registration with unified configuration
+- 🎯 **Auto-Discovery** - Automatic discovery of workflow controllers and scheduled workflows
 - 🔄 **Complete Lifecycle Management** - Automatic worker initialization and graceful shutdown
-- 🎯 **Declarative Decorators** - Type-safe `@Activity()`, `@ActivityMethod()`, `@Workflow()`, and more
-- 🔌 **Connection Management** - Simplified connection handling with TLS support
+- 📋 **Declarative Decorators** - NestJS-style `@WorkflowController`, `@Cron`, `@Interval`, and more
+- 🕐 **Smart Scheduling** - Built-in cron and interval-based workflow scheduling with management
+- 🔌 **Connection Management** - Simplified connection handling with TLS and Temporal Cloud support
 - 🔒 **Type Safety** - Clean, strongly typed interfaces for all Temporal concepts
-- 📡 **Client Utilities** - Methods for starting, signaling, and querying workflows
-- 📊 **Worker Management** - Simple worker lifecycle control and monitoring
-- 📅 **Scheduling** - Support for cron and interval-based workflow scheduling
+- 📡 **Enhanced Client** - Methods for starting, signaling, and querying workflows with auto-discovery
+- 📊 **Worker Management** - Advanced worker lifecycle control, monitoring, and health checks
+- 🏭 **Production Ready** - Environment-aware configuration, health monitoring, and graceful degradation
 
-## Installation
+## 🚀 Quick Start
+
+### Installation
 
 ```bash
 npm install nestjs-temporal-core @temporalio/client @temporalio/worker @temporalio/workflow
 ```
 
-## Quick Start
-
-### 1. Enable Shutdown Hooks
-
-First, make sure to enable shutdown hooks in your `main.ts` file:
-
-```typescript
-async function bootstrap() {
-    const app = await NestFactory.create(AppModule);
-    app.enableShutdownHooks();
-    await app.listen(3000);
-}
-bootstrap();
-```
-
-### 2. Register the Module
+### Basic Setup
 
 ```typescript
+// app.module.ts
 import { Module } from '@nestjs/common';
 import { TemporalModule } from 'nestjs-temporal-core';
-import { EmailActivities } from './activities/email.activities';
 
 @Module({
     imports: [
@@ -65,591 +76,141 @@ import { EmailActivities } from './activities/email.activities';
 export class AppModule {}
 ```
 
-### 3. Define Activities
+### Create a Workflow Controller
 
 ```typescript
-import { Activity, ActivityMethod } from 'nestjs-temporal-core';
-
-@Activity()
-export class EmailActivities {
-    @ActivityMethod()
-    async sendWelcomeEmail(to: string): Promise<boolean> {
-        // Implementation
-        console.log(`Sending welcome email to ${to}`);
-        return true;
-    }
+import { WorkflowController, WorkflowMethod, Cron, Signal, Query } from 'nestjs-temporal-core';
 
-    @ActivityMethod('sendPromoEmail')
-    async sendPromotion(to: string, promoCode: string): Promise<boolean> {
-        // Implementation
-        console.log(`Sending promo ${promoCode} to ${to}`);
-        return true;
+@WorkflowController({ taskQueue: 'orders' })
+export class OrderWorkflowController {
+    private status = 'pending';
+    
+    @WorkflowMethod()
+    async processOrder(orderId: string, customerId: string): Promise<string> {
+        this.status = 'processing';
+        // Workflow logic here
+        this.status = 'completed';
+        return this.status;
     }
-}
-```
-
-### 4. Define Workflows
-
-Create a workflow file in your workflows directory:
-
-```typescript
-// workflows/email-workflow.ts
-import { proxyActivities } from '@temporalio/workflow';
-
-// Activities interface
-interface EmailActivities {
-    sendWelcomeEmail(to: string): Promise<boolean>;
-    sendPromoEmail(to: string, promoCode: string): Promise<boolean>;
-}
-
-const activities = proxyActivities<EmailActivities>({
-    startToCloseTimeout: '30s',
-});
-
-export async function sendWelcomeWorkflow(email: string): Promise<boolean> {
-    return await activities.sendWelcomeEmail(email);
-}
-
-export async function sendPromoWorkflow(email: string, promoCode: string): Promise<boolean> {
-    return await activities.sendPromoEmail(email, promoCode);
-}
-```
 
-### 5. Use the Temporal Service
-
-```typescript
-import { Injectable } from '@nestjs/common';
-import { TemporalService } from 'nestjs-temporal-core';
-
-@Injectable()
-export class EmailService {
-    constructor(private readonly temporalService: TemporalService) {}
-
-    async sendWelcomeEmail(email: string): Promise<string> {
-        // Use the simplified API to start a workflow
-        const { workflowId } = await this.temporalService.startWorkflow(
-            'sendWelcomeWorkflow',
-            [email],
-            'my-task-queue',
-            {
-                workflowId: `welcome-${email}-${Date.now()}`,
-            },
-        );
-
-        return workflowId;
+    @Cron('0 8 * * *', {
+        scheduleId: 'daily-order-report',
+        description: 'Generate daily order report'
+    })
+    @WorkflowMethod()
+    async generateDailyReport(): Promise<void> {
+        console.log('Generating daily order report...');
     }
 
-    async sendPromoEmail(email: string, promoCode: string): Promise<string> {
-        // Use the client service directly for more options
-        const { workflowId } = await this.temporalService
-            .getClient()
-            .startWorkflow('sendPromoWorkflow', [email, promoCode], {
-                taskQueue: 'my-task-queue',
-                workflowId: `promo-${email}-${Date.now()}`,
-                retry: {
-                    maximumAttempts: 3,
-                },
-            });
-
-        return workflowId;
+    @Signal('addItem')
+    async addItemToOrder(item: any): Promise<void> {
+        console.log('Item added to order:', item);
     }
-}
-```
-
-## Advanced Features
-
-### Using Signals and Queries
-
-```typescript
-import { Injectable } from '@nestjs/common';
-import { TemporalService } from 'nestjs-temporal-core';
 
-@Injectable()
-export class OrderService {
-    constructor(private readonly temporalService: TemporalService) {}
-
-    async addItemToOrder(orderId: string, item: string): Promise<void> {
-        // Signal a running workflow
-        await this.temporalService.getClient().signalWorkflow(orderId, 'addItem', [item]);
-    }
-
-    async getOrderStatus(orderId: string): Promise<string> {
-        // Query a running workflow
-        return await this.temporalService.getClient().queryWorkflow(orderId, 'getStatus');
+    @Query('getStatus')
+    getOrderStatus(): string {
+        return this.status;
     }
 }
 ```
 
-### Schedule Management
+### Use the Service
 
 ```typescript
 import { Injectable } from '@nestjs/common';
 import { TemporalService } from 'nestjs-temporal-core';
 
 @Injectable()
-export class ReportingService {
+export class OrderService {
     constructor(private readonly temporalService: TemporalService) {}
 
-    async scheduleDailyReport(): Promise<string> {
-        const handle = await this.temporalService.getScheduleService().createCronWorkflow(
-            'daily-report',
-            'generateReportWorkflow',
-            '0 0 * * *', // Daily at midnight
-            'reports-queue',
-            ['daily-summary'],
+    async processOrder(orderId: string, customerId: string): Promise<string> {
+        const { workflowId } = await this.temporalService.startWorkflow(
+            'processOrder',
+            [orderId, customerId],
+            { workflowId: `order-${orderId}` }
         );
 
-        return handle.scheduleId;
-    }
-
-    async pauseReporting(): Promise<void> {
-        await this.temporalService
-            .getScheduleService()
-            .pauseSchedule('daily-report', 'Paused for maintenance');
-    }
-
-    async resumeReporting(): Promise<void> {
-        await this.temporalService.getScheduleService().resumeSchedule('daily-report');
-    }
-}
-```
-
-## Configuration Options
-
-### Async Configuration
-
-```typescript
-import { Module } from '@nestjs/common';
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import { TemporalModule } from 'nestjs-temporal-core';
-import { EmailActivities } from './activities/email.activities';
-
-@Module({
-    imports: [
-        ConfigModule.forRoot(),
-        TemporalModule.registerAsync({
-            imports: [ConfigModule],
-            inject: [ConfigService],
-            useFactory: (configService: ConfigService) => ({
-                connection: {
-                    address: configService.get('TEMPORAL_ADDRESS'),
-                    namespace: configService.get('TEMPORAL_NAMESPACE'),
-                    apiKey: configService.get('TEMPORAL_API_KEY'),
-                },
-                taskQueue: configService.get('TEMPORAL_TASK_QUEUE'),
-                worker: {
-                    workflowsPath: './dist/workflows',
-                    activityClasses: [EmailActivities],
-                },
-
-                isGlobal: true,
-            }),
-        }),
-    ],
-})
-export class AppModule {}
-```
-
-### Secure Connection with TLS
-
-```typescript
-TemporalModule.register({
-    connection: {
-        address: 'temporal.example.com:7233',
-        namespace: 'production',
-        tls: {
-            // Simple boolean for default TLS
-            // tls: true,
-
-            // Or detailed configuration
-            serverName: 'temporal.example.com',
-            clientCertPair: {
-                crt: fs.readFileSync('./certs/client.crt'),
-                key: fs.readFileSync('./certs/client.key'),
-                ca: fs.readFileSync('./certs/ca.crt'),
-            },
-        },
-        // For Temporal Cloud
-        apiKey: process.env.TEMPORAL_API_KEY,
-    },
-    // ...other options
-});
-```
-
-```
-
-## API Reference
-
-### Core Modules
-
-- `TemporalModule` - Unified module for both client and worker functionality
-- `TemporalClientModule` - Client-only module for workflow operations
-- `TemporalWorkerModule` - Worker-only module for running activities
-
-### Decorators
-
-- `@Activity(options?)` - Marks a class as a Temporal activity
-- `@ActivityMethod(options?)` - Marks a method as an activity implementation
-- `@Workflow(options)` - Marks a class as a Temporal workflow
-- `@WorkflowMethod(options?)` - Marks the primary workflow execution method
-- `@SignalMethod(name?)` - Marks a method as a signal handler
-- `@QueryMethod(name?)` - Marks a method as a query handler
-
-### Services
-
-#### TemporalService
-
-- `getClient()` - Get the client service
-- `getScheduleService()` - Get the schedule service
-- `getWorkerManager()` - Get the worker manager (if available)
-- `startWorkflow()` - Simplified method to start a workflow
-- `hasWorker()` - Check if worker functionality is available
-
-
-#### TemporalClientService
-
-- `startWorkflow()` - Start a new workflow execution
-- `signalWorkflow()` - Send a signal to a running workflow
-- `queryWorkflow()` - Query a running workflow
-- `terminateWorkflow()` - Terminate a running workflow
-- `cancelWorkflow()` - Request cancellation of a workflow
-- `getWorkflowHandle()` - Get a handle to manage a workflow
-- `describeWorkflow()` - Get workflow execution details
-- `listWorkflows()` - List workflows matching a query
-
-#### TemporalScheduleService
-
-- `createCronWorkflow()` - Create a workflow scheduled by cron expression
-- `createIntervalWorkflow()` - Create a workflow scheduled by time interval
-- `pauseSchedule()` - Pause a schedule
-- `resumeSchedule()` - Resume a paused schedule
-- `deleteSchedule()` - Delete a schedule
-- `triggerNow()` - Trigger an immediate execution
-- `listSchedules()` - List all schedules
-
-#### WorkerManager
-
-- `startWorker()` - Manually start the worker
-- `shutdown()` - Gracefully shutdown the worker
-- `getWorker()` - Get the underlying worker instance
-
-## Project Structure
-
-When integrating Temporal with your NestJS application, organizing your code properly helps maintain separation of concerns and follows NestJS conventions. Here's a recommended project structure:
-
-```
-
-```
-src/
-├── temporal/
-│ ├── activities/
-│ │ ├── email.activities.ts
-│ │ ├── payment.activities.ts
-│ │ └── index.ts
-│ ├── workflows/
-│ │ ├── email-workflows.ts
-│ │ ├── payment-workflows.ts
-│ │ └── index.ts
-│ ├── interfaces/
-│ │ ├── email.interfaces.ts
-│ │ └── payment.interfaces.ts
-│ └── temporal.module.ts
-├── modules/
-│ ├── email/
-│ │ ├── email.service.ts
-│ │ ├── email.controller.ts
-│ │ └── email.module.ts
-│ └── payment/
-│ ├── payment.service.ts
-│ ├── payment.controller.ts
-│ └── payment.module.ts
-└── app.module.ts
-
-```
-
-### Key Files and Their Purpose
-
-1. **Activities (src/temporal/activities/)**:
-
-    - Contains activity classes decorated with `@Activity()`
-    - Each activity class should group related functionality
-
-2. **Workflows (src/temporal/workflows/)**:
-
-    - Contains workflow definitions that orchestrate activities
-    - Workflows should be in separate files based on domain
-
-3. **Interfaces (src/temporal/interfaces/)**:
-
-    - TypeScript interfaces that define activity and workflow parameters/returns
-    - Helps maintain type safety between activities and workflows
-
-4. **Temporal Module (src/temporal/temporal.module.ts)**:
-
-    - Centralizes Temporal configuration
-    - Imports and registers all activities
-
-5. **Business Services (src/modules/\*/)**:
-    - Inject the TemporalService
-    - Use it to start workflows and interact with Temporal
-
-## Integration Examples
-
-### Activity Definition
-
-```typescript
-// src/temporal/activities/email.activities.ts
-import { Activity, ActivityMethod } from 'nestjs-temporal-core';
-import { Injectable } from '@nestjs/common';
-import { EmailService } from '../../modules/email/email.service';
-
-@Injectable()
-@Activity()
-export class EmailActivities {
-    constructor(private readonly emailService: EmailService) {}
-
-    @ActivityMethod()
-    async sendWelcomeEmail(to: string, name: string): Promise<boolean> {
-        await this.emailService.sendEmail({
-            to,
-            subject: 'Welcome!',
-            body: `Hello ${name}, welcome to our platform!`,
-        });
-        return true;
-    }
-
-    @ActivityMethod()
-    async sendPasswordReset(to: string, resetToken: string): Promise<boolean> {
-        await this.emailService.sendEmail({
-            to,
-            subject: 'Password Reset',
-            body: `Please use this token to reset your password: ${resetToken}`,
-        });
-        return true;
-    }
-}
-```
-
-```typescript
-// src/temporal/activities/index.ts
-export * from './email.activities';
-export * from './payment.activities';
-// Export all other activity classes
-```
-
-### Workflow Definition
-
-```typescript
-// src/temporal/workflows/email-workflows.ts
-import { proxyActivities } from '@temporalio/workflow';
-
-// Define the interface of activities this workflow will use
-export interface EmailActivities {
-    sendWelcomeEmail(to: string, name: string): Promise<boolean>;
-    sendPasswordReset(to: string, resetToken: string): Promise<boolean>;
-}
-
-// Create a proxy to the activities
-const activities = proxyActivities<EmailActivities>({
-    startToCloseTimeout: '30 seconds',
-});
-
-// Welcome workflow with retry logic
-export async function welcomeUserWorkflow(email: string, name: string): Promise<boolean> {
-    let attempts = 0;
-    const maxAttempts = 3;
-
-    while (attempts < maxAttempts) {
-        try {
-            return await activities.sendWelcomeEmail(email, name);
-        } catch (error) {
-            attempts++;
-            if (attempts >= maxAttempts) {
-                throw error;
-            }
-            // Wait before retrying
-            await new Promise((resolve) => setTimeout(resolve, 5000));
-        }
+        return workflowId;
     }
-
-    return false;
-}
-
-// Password reset workflow
-export async function passwordResetWorkflow(email: string, resetToken: string): Promise<boolean> {
-    return await activities.sendPasswordReset(email, resetToken);
 }
 ```
 
-### Scheduled Workflow Example
-
-```typescript
-// src/temporal/workflows/scheduled-workflows.ts
-import { proxyActivities } from '@temporalio/workflow';
+## 📖 Core Concepts
 
-interface ReportActivities {
-    generateDailyReport(): Promise<string>;
-    emailReportToAdmins(reportUrl: string): Promise<boolean>;
-}
+### Workflow Controllers
+New NestJS-style controllers for defining workflows with auto-discovery and declarative scheduling.
 
-const activities = proxyActivities<ReportActivities>({
-    startToCloseTimeout: '10 minutes',
-});
+### Activities  
+Reusable business logic components that can be called from workflows.
 
-// This workflow will be scheduled to run daily
-export async function dailyReportWorkflow(): Promise<void> {
-    const reportUrl = await activities.generateDailyReport();
-    await activities.emailReportToAdmins(reportUrl);
-}
-```
+### Scheduling
+Built-in support for cron and interval-based workflow scheduling using decorators.
 
-### Setting Up the Temporal Module
+### Auto-Discovery
+Automatic detection and registration of workflow controllers and scheduled workflows.
 
-```typescript
-// src/temporal/temporal.module.ts
-import { Module } from '@nestjs/common';
-import { TemporalModule } from 'nestjs-temporal-core';
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import * as path from 'path';
-import { EmailActivities, PaymentActivities } from './activities';
-import { EmailModule } from '../modules/email/email.module';
-import { PaymentModule } from '../modules/payment/payment.module';
+## 🏗️ Architecture
 
-@Module({
-    imports: [
-        EmailModule,
-        PaymentModule,
-        TemporalModule.registerAsync({
-            imports: [ConfigModule],
-            inject: [ConfigService],
-            useFactory: (configService: ConfigService) => ({
-                connection: {
-                    address: configService.get('TEMPORAL_ADDRESS', 'localhost:7233'),
-                    namespace: configService.get('TEMPORAL_NAMESPACE', 'default'),
-                },
-                taskQueue: configService.get('TEMPORAL_TASK_QUEUE', 'my-app-queue'),
-                worker: {
-                    workflowsPath: path.resolve(__dirname, 'workflows'),
-                    activityClasses: [EmailActivities, PaymentActivities],
-                    autoStart: true,
-                },
-                isGlobal: true,
-            }),
-        }),
-    ],
-    providers: [EmailActivities, PaymentActivities],
-    exports: [TemporalModule],
-})
-export class TemporalAppModule {}
 ```
-
-### Using Temporal in Business Services
-
-```typescript
-// src/modules/email/email.service.ts
-import { Injectable } from '@nestjs/common';
-import { TemporalService } from 'nestjs-temporal-core';
-
-@Injectable()
-export class EmailService {
-    constructor(private readonly temporalService: TemporalService) {}
-
-    // Your actual email sending functionality
-    async sendEmail(options: { to: string; subject: string; body: string }): Promise<void> {
-        // Implementation...
-    }
-
-    // Triggering a Temporal workflow
-    async sendWelcomeEmail(email: string, name: string): Promise<string> {
-        const { workflowId } = await this.temporalService.startWorkflow(
-            'welcomeUserWorkflow',
-            [email, name],
-            'my-app-queue',
-            { workflowId: `welcome-${email}-${Date.now()}` },
-        );
-
-        return workflowId;
-    }
-}
+┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
+│   NestJS App    │    │ Temporal Server  │    │  Worker Process │
+│                 │    │                  │    │                 │
+│ ┌─────────────┐ │    │ ┌──────────────┐ │    │ ┌─────────────┐ │
+│ │ Controllers │ │───▶│ │  Workflows   │ │───▶│ │ Activities  │ │
+│ │   Services  │ │    │ │  Schedules   │ │    │ │  Workers    │ │
+│ └─────────────┘ │    │ └──────────────┘ │    │ └─────────────┘ │
+└─────────────────┘    └──────────────────┘    └─────────────────┘
 ```
 
-### Setting Up Scheduled Workflows
+## 🎯 Use Cases
 
-```typescript
-// src/modules/reports/report.service.ts
-import { Injectable, OnModuleInit } from '@nestjs/common';
-import { TemporalService } from 'nestjs-temporal-core';
-
-@Injectable()
-export class ReportService implements OnModuleInit {
-    constructor(private readonly temporalService: TemporalService) {}
-
-    async onModuleInit() {
-        // Set up scheduled workflows when the module initializes
-        await this.setupDailyReport();
-    }
-
-    private async setupDailyReport() {
-        try {
-            // Check if the schedule already exists
-            const schedules = await this.temporalService.getScheduleService().listSchedules();
-
-            if (!schedules.some((s) => s.scheduleId === 'daily-report')) {
-                // Create a new schedule
-                await this.temporalService.getScheduleService().createCronWorkflow(
-                    'daily-report',
-                    'dailyReportWorkflow',
-                    '0 8 * * *', // Run every day at 8 AM
-                    'my-app-queue',
-                    [], // No arguments needed for this workflow
-                    'Daily business report generation',
-                );
-
-                console.log('Daily report schedule created');
-            }
-        } catch (error) {
-            console.error('Failed to set up daily report schedule:', error);
-        }
-    }
-}
-```
+- **Order Processing** - Reliable order fulfillment with compensation
+- **Payment Processing** - Multi-step payment flows with retries
+- **Data Pipelines** - Long-running data processing workflows
+- **Scheduled Jobs** - Cron-based and interval-based background tasks
+- **Saga Patterns** - Distributed transaction management
+- **Human Tasks** - Workflows requiring human intervention
+- **Microservice Orchestration** - Coordinating multiple services
 
-## Best Practices
+## 🌟 What's New in v3.0
 
-1. **Activity Design**
+- **🎮 Workflow Controllers** - NestJS-style workflow definition
+- **📅 Declarative Scheduling** - `@Cron` and `@Interval` decorators
+- **🔍 Auto-Discovery** - Automatic workflow and schedule detection
+- **📊 Enhanced Monitoring** - Built-in health checks and metrics
+- **🏭 Production Features** - Worker presets, graceful shutdown, error handling
+- **🔧 Better Developer Experience** - Improved APIs and TypeScript support
 
-    - Keep activities focused on single responsibilities
-    - Set appropriate timeouts for expected durations
-    - Use dependency injection within activity classes
+## 📦 Packages
 
-2. **Workflow Design**
+| Package                | Version                                                                                                             | Description              |
+| ---------------------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------ |
+| `nestjs-temporal-core` | [![npm](https://img.shields.io/npm/v/nestjs-temporal-core.svg)](https://www.npmjs.com/package/nestjs-temporal-core) | Main integration package |
+| `@temporalio/client`   | [![npm](https://img.shields.io/npm/v/@temporalio/client.svg)](https://www.npmjs.com/package/@temporalio/client)     | Temporal client library  |
+| `@temporalio/worker`   | [![npm](https://img.shields.io/npm/v/@temporalio/worker.svg)](https://www.npmjs.com/package/@temporalio/worker)     | Temporal worker library  |
+| `@temporalio/workflow` | [![npm](https://img.shields.io/npm/v/@temporalio/workflow.svg)](https://www.npmjs.com/package/@temporalio/workflow) | Workflow runtime library |
 
-    - Make workflows deterministic
-    - Use signals for external events
-    - Use queries for retrieving workflow state
-    - Separate workflows by domain/function
+## 🤝 Community
 
-3. **Configuration**
+- **GitHub Discussions** - Ask questions and share ideas
+- **Issues** - Report bugs and request features  
+- **Pull Requests** - Contribute to the project
 
-    - Use meaningful workflow IDs for tracking
-    - Configure appropriate timeouts for activities and workflows
-    - Implement proper error handling
+## 📄 License
 
-4. **Lifecycle Management**
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
-    - Enable NestJS shutdown hooks
-    - Configure proper worker shutdown grace periods
-    - Consider using OnModuleInit to set up schedules
+## 👨‍💻 Author
 
-5. **Security**
-    - Implement proper TLS security for production environments
-    - Use namespaces to isolate different environments
-    - Use API keys for Temporal Cloud authentication
+**Harsh M** - [GitHub](https://github.com/harsh-simform)
 
-## License
+## 🙏 Acknowledgments
 
-MIT
+- [Temporal.io](https://temporal.io/) - For the amazing workflow engine
+- [NestJS](https://nestjs.com/) - For the incredible framework
+- [TypeScript](https://www.typescriptlang.org/) - For making JavaScript enjoyable
 
-## Author
+---
 
-Harsh M
+**[📚 Continue to Getting Started →](./docs/getting-started.md)**