> For the complete documentation index, see [llms.txt](https://transactional.gitbook.io/documentation/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://transactional.gitbook.io/documentation/propagation.md).

# Propagation

Propagation will help to determine when the query should run in a transaction and what transaction to use. 

## REQUIRED (default)

In `REQUIRED` mode, the function will inspect the context for a transaction, use one if exists and create a new one if none exists.

```typescript
class Service {
    @Transactional(Propagation.REQUIRED)
    async methodA() {
        // methodA will create a transaction.
        
        // methodB will use transaction created by methodA.
        await this.methodB();
    }
    
    @Transactional(Propagation.REQUIRED)
    async methodB() { ... }
}
```

## REQUIRES\_NEW

In `REQUIRES_NEW` mode, the function will always create and use a new transaction and assign it to the subsequent async context, even if one exists in the current context.

```typescript
class Service {
    @Transactional(Propagation.REQUIRED)
    async methodA() {
        // methodA will create a transaction.
    
        // methodB will alwyas use a different transaction that methodA.
        await this.methodB();
        // methodB transaction will be commited here.
        
        // queries here will use methodA transaction.
    }
    
    @Transactional(Propagation.REQUIRES_NEW)
    async methodB() { ... }
}
```

## MANDATORY

In `Mandatory` mode, the function will inspect the context for a transaction, if it finds a transaction it will use it, if it does not it will throw an error.

```typescript
class Service {
    @Transactional()
    async methodA() {
        await this.methodB();
    }
    
    @Transactional(Propagation.MANDATORY)
    async methodB() { ... }
}

const service = new Service();

// works
await service.methodA();

// throws an error
await service.methodB();
```

## SUPPORTS

In `SUPPORTS` mode, the function will inspect the context for a transaction, if it finds one it will use it, if not, it will run the queries without a transaction.

```typescript
class Service {
    @Transactional(Propagation.REQUIRED)
    async methodA() {
        
        // methodB queries will run inside method A transaction.
        await this.methodB();
    }
    
    @Transactional(Propagation.SUPPORTS)
    async methodB() { ... }
}

const service = new Service();

// methodB queries will run inside method A transaction.
await service.methodA();

// methodB queries will run outside a transaction.
await service.methodB();
```

## NOT\_SUPPORTED

In `NOT_SUPPORTS` mode, the function will always run outside the current context transaction.

```typescript
class Service {
    @Transactional(Propagation.REQUIRED)
    async methodA() {
        
        // methodB queries will run outside method A transaction.
        await this.methodB();
    }
    
    @Transactional(Propagation.NOT_SUPPORTED)
    async methodB() { ... }
}
```

## NEVER

In `NEVER` mode, the function will run outside a transaction if non exists in the current context, and will throw an error if a transaction exists in the current context.

```typescript
class Service {
    @Transactional(Propagation.REQUIRED)
    async methodA() {
        
        // will throw an error since the context has a transaction.
        await this.methodB();
    }
    
    @Transactional(Propagation.NEVER)
    async methodB() { ... }
}

const service = new Service();

// throws an error.
await service.methodA();

// works.
await service.methodB();
```