Ondřej Tůma

[Vendure.io](https://vendure.io) is a great framework, but the [official documentation](https://docs.vendure.io/guides/developer-guide/error-handling/) does not specify anything related to error logging, or even where does the error boundary end.

Vendure does by default handle all errors thrown through the graphql and rest endpoints.

But it is quite easy to stop the whole server by simply not handling exception for example in event subscribers.
```typescript
async onApplicationBootstrap() 
{

    this.eventBus
        .ofType(eventType)
        .pipe(filterRule)
        .subscribe(async (event) => {
            throw new Error('Not allowed')
        });
}
```
You will stop the entire server process by throwing exception, and it is quite easy to do such mistake.

# Setup

## Install sentry
```typescript
yarn add @sentry/node
yarn add @sentry/tracing
```

## Initialize sentry
in your vendure-config file
```typescript
Sentry.init({  
    dsn: SENTRY_DSN,  
    tracesSampleRate: 1.0,  
    debug: IS_DEV,  
});

export const config: VendureConfig = {
...
}
```

# Handling for server
Errors that are thrown during the request-response cycle are caught and returned in the graphql. So here we only need to add logging.
## Create Exception filter
```typescript
import { ArgumentsHost, Catch, ExceptionFilter } from '@nestjs/common';  
import * as Sentry from "@sentry/node";  
import "@sentry/tracing";  
  

@Catch()  
export class SentryExceptionFilter implements ExceptionFilter {  
    catch(exception: Error, host: ArgumentsHost) {
        Sentry.captureException(exception)  
    }  
}
```

## In some plugin
```typescript
@VendurePlugin({  
    ...
    providers: [  
        ...
        {  
            provide: APP_FILTER,  
            useClass: SentryExceptionFilter,  
        },  
    ],  
})
```

This captures the error when returing through GraphQL, but it still does not solve the issue for consumers and cronjobs. 

# Handling in event subscribers
To make sure all subscribers are error-free, I created a simple reusable event subscriber.
```typescript
export abstract class BaseSubscriber<T extends VendureEvent & {ctx: RequestContext}> {
    constructor(
        protected transactionalConnection: TransactionalConnection
    ) {
    }

    public async subscribe(event: T): Promise<void> {
        try {
            await this.transactionalConnection.withTransaction(event.ctx, async (ctx) => {
                await this.doSubscribe(ctx, event);
            })
        } catch (e) {
            Sentry.captureException(e);
        }
    }

    protected abstract doSubscribe(ctx: RequestContext, event: T): Promise<void>;
}
```

The actual event subscriber will look like this
```typescript
@Injectable()
export class FulfillmentOnFulfillmentCreatedSubscriber extends BaseSubscriber<FulfillmentEvent> {
    public static eventType = FulfillmentEvent;
    public static filterRule = filter((event: FulfillmentEvent) => event.entity.handlerCode === CONTEST_FULFILLMENT_HANDLER_CODE);

    constructor(
        transactionalConnection: TransactionalConnection
    ) {
        super(transactionalConnection);
    }

    public async doSubscribe(ctx: RequestContext, event: FulfillmentEvent): Promise<void>
    {
        // do your action
    }
}
```
Then add the event subscriber like so in your plugin
```typescript
async onApplicationBootstrap() {
    this.eventBus
        .ofType(CouponFulfillmentOnPaymentSettledSubscriber.eventType)
        .pipe(CouponFulfillmentOnPaymentSettledSubscriber.filterRule)
        .subscribe(this.couponFulfillmentOnPaymentSettledSubscriber.subscribe);
}
```

# Handling for crons
Manually wrapping each cron in the exception handler
```typescript
const createSafeTransactionalCron = (app: INestApplicationContext, time: string, callback: (ctx: RequestContext) => Promise<void>) => {  
    return new CronJob(time, async () => {  
        const sentryLogger = app.get(SentryLogger);  
        const connection = app.get(TransactionalConnection);  
  
        try {  
            await connection.withTransaction(async (ctx) => {  
                await callback(ctx)  
            })  
        } catch (e) {  
            sentryLogger.logException(e);  
        }  
    })  
}
```

## In worker
```typescript
bootstrapWorker(config)  
.then(worker => {  
    const job = createSafeTransactionalCron(worker.app, `*/15 * * * * *`, async (ctx) => {  
        throw new Error('Test error');
    });  
    job.start();  
})
```

This should ensure that the app does not crash, and all exceptions will be visible in Sentry



# The technical side
The technical side was set of extensions for the [vendure](https://vendure.io) ecommerce platform together with custom storefront.

It included extensions for the following functions
- contest events
- coupon codes handling and automated email fulfillment
- integration with [zalando](https://zalando.com)
- gopay integration
- payU integration
- [pohoda](https://pohoda.cz) accounting integration



# Project
Voting platform that enables the judges of a competition to vote for the winner. It was an internal tool developed for the finale in 2021.

It was designed to work for the onboarding and internal processes for next years.



2021 - present	ShipMonk	Backend developer (Senior PHP)
2020 - 2021	NFCtron	Backend developer (PHP, Nest.js)
2019 - 2019	AI Center	Tooling developer (Python)
2016 - 2016	MALPRO	Automation developer (Python)

I am a DeveloperStudentCreativeMinimalist

Latest projects

Awincado

Leaves Bar

Miss Czech Republic

Latest blog posts

Contact