feat: pass sentry instance

Closes #41

Author: herkulano

README.md

@@ -29,12 +29,14 @@ const resolvers = {
   }
 }
 
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  environment: process.env.NODE_ENV,
+  release: process.env.npm_package_version
+})
+
 const sentryMiddleware = sentry({
-  config: {
-    dsn: process.env.SENTRY_DSN,
-    environment: process.env.NODE_ENV,
-    release: process.env.npm_package_version
-  },
+  sentryInstance: Sentry,
   withScope: (scope, error, context) => {
     scope.setUser({
       id: context.authorization.userId,
@@ -58,7 +60,7 @@ serve.start(() => `Server running on http://localhost:4000`)
 
 ```ts
 export interface Options<Context> {
-  config: Sentry.NodeOptions
+  sentryInstance: Sentry
   withScope?: ExceptionScope<Context>
   captureReturnedErrors?: boolean
   forwardErrors?: boolean
@@ -77,7 +79,7 @@ The `withScope` option is a function that is called with the current Sentry scop
 ```ts
 type ExceptionScope<Context> = (
   scope: Sentry.Scope,
-  error: any,
+  error: Error,
   context: Context,
 ) => void
 ```
@@ -86,7 +88,7 @@ type ExceptionScope<Context> = (
 
 | property                | required | description                                                                                                                                                                |
 | ----------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `config`                | true     | [Sentry's config object](https://docs.sentry.io/error-reporting/configuration/?platform=node)                                                                              |
+| `sentryInstance`        | true     | [Sentry's instance](https://docs.sentry.io/error-reporting/configuration/?platform=node)                                                                                   |
 | `withScope`             | false    | Function to modify the [Sentry context](https://docs.sentry.io/enriching-error-data/context/?platform=node) to send with the captured error.                               |
 | `captureReturnedErrors` | false    | Capture errors returned from other middlewares, e.g., `graphql-shield` [returns errors](https://github.com/maticzav/graphql-shield#custom-errors) from rules and resolvers |
 | `forwardErrors`         | false    | Should middleware forward errors to the client or block them.                                                                                                              |

src/index.ts

@@ -1,16 +1,16 @@
-import * as Sentry from '@sentry/node'
+import { Scope } from '@sentry/core'
 
 import { IMiddlewareFunction } from 'graphql-middleware/dist/types'
 
 export type ExceptionScope<Context> = (
-  scope: Sentry.Scope,
-  error: any,
+  scope: Scope,
+  error: Error,
   context: Context,
 ) => void
 
 // Options for graphql-middleware-sentry
 export interface Options<Context> {
-  config: Sentry.NodeOptions
+  sentryInstance: any
   withScope?: ExceptionScope<Context>
   captureReturnedErrors?: boolean
   forwardErrors?: boolean
@@ -19,45 +19,43 @@ export interface Options<Context> {
 export class SentryError extends Error {}
 
 export const sentry = <Context>({
-  config = {},
+  sentryInstance = null,
   withScope,
   captureReturnedErrors = false,
   forwardErrors = false,
 }: Options<Context>): IMiddlewareFunction => {
   // Check if Sentry DSN is present
-  if (!config.dsn) {
-    throw new SentryError(`Missing dsn parameter in configuration.`)
+  if (!sentryInstance) {
+    throw new SentryError(`The Sentry instance is missing in the options.`)
   }
 
-  // Init Sentry
-  Sentry.init(config)
-
   // Return middleware resolver
-  return async function(resolve, parent, args, ctx, info) {
+  return async (resolve, parent, args, ctx, info) => {
     try {
       const res = await resolve(parent, args, ctx, info)
       if (captureReturnedErrors && res instanceof Error) {
-        captureException(res, ctx, withScope)
+        captureException(sentryInstance, res, ctx, withScope)
       }
       return res
-    } catch (err) {
-      captureException(err, ctx, withScope)
+    } catch (error) {
+      captureException(sentryInstance, error, ctx, withScope)
 
       // Forward error
       if (forwardErrors) {
-        throw err
+        throw error
       }
     }
   }
 }
 
 function captureException<Context>(
-  err,
+  sentryInstance,
+  error: Error,
   ctx: Context,
   withScope: ExceptionScope<Context>,
 ) {
-  Sentry.withScope(scope => {
-    withScope(scope, err, ctx)
-    Sentry.captureException(err)
+  sentryInstance.withScope(scope => {
+    withScope(scope, error, ctx)
+    sentryInstance.captureException(error)
   })
 }