@nerjs/gql v1.5.0

Gql (apollo) config and utils

Install

npm i @nerjs/gql

or:

yarn add @nerjs/gql

Use

createClient()

create Apollo client.

const createClient = require('@nerjs/gql/client')
// or
import createClient from '@nerjs/gql/client'


const client = createClient({/* ...clientOptions */})

clientOptions

createGqlServer

create ApolloServer

const createGqlServer = require('@nerjs/gql/server')

const server = createGqlServer({/* ...serverOptions */})

serverOptions

GqlProvider

React component. Wrap over ApolloProvider.

const GqlProvider = require('@nerjs/gql/provider')
// or
import GqlProvider from '@nerjs/gql/provider'
import React from 'react'


const App = () => {
    return <GqlProvider {.../* providerProps */} />
}

providerProps

1. client: (ApolloClient): Required if not use clientOptions

or:

2. {...options} clientOptions

useGqlErrors

const useGqlErrors = require('@nerjs/gql/useGqlErrors')
// or
import useGqlErrors from '@nerjs/gql/useGqlErrors'

const { lastError } = useGqlErrors()

Returns the last error Does not work outside the GqlProvider or when using the first option

Scalars (resolvers)

const { ...scalars } = require('@nerjs/gql/scalars')

• DateResolver (scalar Date)
• NumberResolver (scalar Number)

gql middlewares

const { ...middlewares } = require('@nerjs/gql/mdw')

validate middleware

const validateMiddleware = require('@nerjs/gql/mdw/validate')


const schemaMiddlewares = {
    Query: {
        getItem: validateMiddleware({ input: yupInputSchema }),
        getItems: validateMiddleware(yupInputSchema)
    }
}

Used yup validation default errorWrapper YupGqlError

Custom (not yup) validation

The schema must have a .validate(input) method

const { createValidateMiddleware } = require('@nerjs/gql/mdw/validate')

const validateMiddleware = createValidateMiddleware({
    isSchemaField: '__isYupSchema__', // The property of an object, by which it is clear that this is a validator scheme
    schemaOptions: { abortEarly: false },
    errorWrapper: Error
})

notNull middleware

Prevents return NULL

const notNullMiddleware = require('@nerjs/gql/mdw/notNull')

const schemaMiddlewares = {
    User: {
        getUser: notNullMiddleware('User not found' /* error message */)
    }
}

throw NotFoundGqlError(message) if resolver return null

onlyId middleware

Prevents unnecessary resolver calls

const onlyIdMiddleware = require('@nerjs/gql/mdw/onlyId')

const schemaMiddlewares = {
    Post: {
        author: onlyIdMiddleware()
    }
}

returnBoolean middleware

Returns a boolean value depending on the success of the resolver. If preventError is specified as true - returns false instead of an exception

const returnBooleanMiddleware = require('@nerjs/gql/mdw/returnBoolean')

const schemaMiddlewares = {
    Post: {
        author: onlyIdMiddleware(/* preventError = false */)
    }
}

combine middlewares

Combines and launches middlewares

const combineMiddlewares = require('@nerjs/gql/mdw/combine')

const schemaMiddlewares = {
    Post: {
        author: combine(
            onlyIdMiddleware(),
            notNullMiddleware('Not foud author')
        )
    }
}

:link: All utils