ProjectX

ProjectX is a comprehensive full-stack template designed to simplify the development of scalable and resilient applications using React and Temporal. By integrating Temporal's advanced workflow orchestration with React's dynamic frontend framework, ProjectX enables developers to build applications with durable executions and seamless communication between services.

<details> <summary><h2>Features 🧰</h2></summary> - ⏳ Temporal TypeScript SDK running from a Turborepo monorepo - 🧭 React Router v7 (Framework mode) + React Query - 🎨 TailwindCSS v4 - 🧱 NestJS for APIs & microservices - 🐳 Docker setup to run everything locally on any machine - 🤖 AI-first with Cursor Rules + MCP servers & Claude Subagents + Skills - 📚 Storybook for building UI components - 📧 MJML for lightning-fast email templates - 🛒 Stripe for checkout & payments - 🪝 Ngrok for local integrations and webhooks </details>

Why Temporal? 🤔

Challenges of Maintaining State in Distributed Systems

Consistency
Fault Tolerance
Scalability
Concurrency Control
Security

Temporal is introduced here as a Workflow Orchestration tool for managing long-running operations (durable execution), human-in-the-loop and system lifecycle (state management, guaranteed completion with compensations and uniqueness). You can use Temporal today to implement sequences of steps/actions in a specific order for your business processes (workflows), not only for communication between services (Microservices Orchestration) but also within Monolithic apps. Workflows can react to asynchronous and external events (signals, updates), aggregate data and perform actions (activities) with exponential retries (retry policy) and run for extended periods (heartbeat) if needed, then you can check the state of these executions at any time (queries). Additionally, workflows support scheduled and time-based executions with configurable delays to handle recurring business logic (scheduling).

Use Cases

• Order Processing Systems: Managing the lifecycle of orders from placement to fulfillment, including inventory checks, payment processing, and shipping.

• User Onboarding: Coordinating steps involved in onboarding new users, such as account creation, email verification, and initial setup tasks.

• Data Pipelines: Orchestrating data ingestion, transformation, and storage processes with reliability and scalability.

• Batch Processing: Handling large-scale batch jobs with retry mechanisms and progress monitoring.

Getting Started 🚀

Prerequisites 🧰

Quick Setup 🛠️

Clone and Setup Environment:

git clone https://github.com/proyecto26/projectx.git
cd projectx
cp .env.example .env

Start Development Environment:

# Build and start all services (db, temporal, backend services)
docker-compose up -d

# Install dependencies and start web application
pnpm install
pnpm run dev:web

Documentation 📚

For detailed information about the project, please refer to:

Project Structure Overview

<img width="1204" alt="image" src="https://github.com/user-attachments/assets/6a82fc7a-178a-42e1-8d27-fbb353422793" /> <details> <summary>Markmap format 🍬</summary>

#### Root Directory

- **package.json**: Contains the dependencies and scripts for the entire monorepo.
- **turbo.json**: Configuration for Turborepo, which manages the monorepo structure and build processes.
- **tsconfig.json**: Base TypeScript configuration shared across the project.

#### Apps

- **apps/auth**: 
  - **Purpose**: Handles user authentication and data retrieval.
  - **Key Features**: Login, registration, and user profile management.

- **apps/order**: 
  - **Purpose**: Manages order processing, checkout, and payment handling.
  - **Key Features**: Cart management, order tracking, and payment integration.

- **apps/product**: 
  - **Purpose**: Manages product catalog and inventory.
  - **Key Features**: Product listing, details, and inventory management.

- **apps/web**: 
  - **Purpose**: The main web application interface.
  - **Key Features**: User interaction with the system.
  - **Configuration**: 
    - **tsconfig.json**: TypeScript configuration specific to the web app.

#### Packages

- **packages/core**: 
  - **Purpose**: Contains business logic and common utilities.
  - **Key Features**: Shared functions and services used across backend applications.

- **packages/db**: 
  - **Purpose**: Manages database access using Prisma and the Repository pattern.
  - **Key Features**: Database schema definitions and data access layers.
  - **Documentation**: 
    - **README.md**: Provides details on database setup and usage.

- **packages/email**: 
  - **Purpose**: Handles email template creation and sending.
  - **Key Features**: Uses MJML for templates and provides email sending services.

- **packages/models**: 
  - **Purpose**: Defines DTOs and common types.
  - **Key Features**: Ensures consistency across web and backend services.

- **packages/ui**: 
  - **Purpose**: Contains UI components and themes.
  - **Key Features**: Built with React and TailwindCSS, includes Storybook for component visualization.
  - **Configuration**: 
    - **package.json**: Dependencies and scripts for the UI library.
    - **tsconfig.json**: TypeScript configuration for the UI library.

- **packages/workflows**: 
  - **Purpose**: Temporal workflow orchestration utilities.
  - **Key Features**: Shared workflow client and worker services.

- **packages/payment**: 
  - **Purpose**: Payment provider integrations.
  - **Key Features**: Stripe and other payment gateway implementations.

</details>

Code Generators 🏗️

ProjectX includes powerful Turborepo generators to scaffold new services quickly and consistently.

Available Generators

| Command | Description | |---------|-------------| | pnpm gen:service | Create a basic NestJS microservice (like product) | | pnpm gen:temporal-service | Create a NestJS service with Temporal workflows (like auth, order) | | pnpm gen:workflow | Add a new workflow to an existing Temporal-enabled service |

Creating a New Service

Basic Service (without Temporal)

pnpm gen:service

This will prompt you for:

Service name (e.g., inventory, notification)
Port number (auto-suggests next available)
Description
Optional modules (Email, Payment)

Temporal-Enabled Service

pnpm gen:temporal-service

Additional prompts:

Initial workflow name (e.g., process, handle)

Adding a Workflow to Existing Service

pnpm gen:workflow

Select the target service and provide workflow details.

What Gets Generated

Basic Service:

apps/{serviceName}/
├── src/
│   ├── app/
│   │   ├── app.module.ts
│   │   ├── app.controller.ts
│   │   └── app.service.ts
│   ├── config/
│   │   ├── app.config.ts
│   │   ├── env.config.ts
│   │   └── swagger.config.ts
│   └── main.ts
├── test/
├── package.json
└── tsconfig.json

Temporal Service (additional):

├── src/
│   ├── app/activities/
│   │   ├── activities.module.ts
│   │   └── activities.service.ts
│   ├── config/
│   │   └── temporal.config.ts
│   └── workflows/
│       ├── index.ts
│       └── {workflowName}.workflow.ts

Auto-Configuration

The generators automatically:

Add dev:{serviceName} and build:{serviceName} scripts to root package.json
Update docker-compose.yml with the new service configuration
Configure the builder to include the new service in the build pipeline

Post-Generation Steps

Add the environment variable to .env:
```
{SERVICE_NAME}_PORT={port}
```
Install dependencies:
```
pnpm install
```
Start the service:
```
pnpm dev:{serviceName}
```

ProjectX CLI 🖥️

ProjectX includes an interactive CLI tool for a more developer-friendly experience when generating services and customizing the template.

Running the CLI

# Interactive mode (recommended)
pnpm cli

# Or run specific commands
pnpm cli generate service
pnpm cli generate temporal-service
pnpm cli generate workflow
pnpm cli init
pnpm cli info

CLI Commands

| Command | Description | |---------|-------------| | pnpm cli | Interactive mode - select what to do | | pnpm cli generate [type] | Generate service or workflow | | pnpm cli init

Projectx

Install / Use

README