Skip to main content
Version: 3.0

Resolvers

Resolvers of the application are responsible for handling incoming requests and returning responses to the client.

Example banner

Install package​

npm install @orion-js/resolvers

The structure of the main resolvers of the application​

app
└── resolvers
    ├── resolver1
    │   └── index.ts
    ├── resolver2
    │   └── index.ts
    └── index.ts
  • Folder resolvers: The directory of the set of resolvers.
  • resolver1 & resolver2: Function to execute routines, query the database and return data with defined structures.
info

The routing mechanism is self-managed by name as you export default in the main index.ts file in the resolvers folder. For example, if you want to make a query when resolver1 and the server is running (http://localhost:3000/graphiql), you can send a request through GraphQL as follows:

{
  resolver1
}

Example of the resolvers directory index.ts​

app/resolvers/index.ts
import resolver1 from './resolver1'
import resolver2 from './resolver2'

export default {
  resolver1,
  resolver2
}

Resolver types​

Query resolver​

Query resolvers are controllers that can receive parameters and use them for a specific calculation, or to make a GraphQL Query to the database to return an element with its defined schema or of some other specific type.

import {resolver} from '@orion-js/resolvers'

export default resolver({
  params: {
    parameter1: {
      type: String
    }
  },
  returns: String,
  async resolve(params, viewer) {
    return `Hello world, ${params.parameter1}`
  }
})

Cache​

You can add cache policy to your resolvers by adding a cache property specifying a number of milliseconds:

cache: 1000 * 60 * 60, // Cache 1 hour in milliseconds

Example:

import {resolver} from '@orion-js/resolvers'

const ONE_HOUR_MILLISECONDS = 3600000

export default resolver({
  cache: ONE_HOUR_MILLISECONDS,
  params: {},
  returns: String,
  async resolve(params, viewer) {
    return `Hello Cached`
  }
})

Permissions​

You can check if the user perfoming the query or mutation has permission (or any condition) adding a checkPermission function to the resolver configuration object.

  • This function receives the resolvers parameters and the current viwer, an object representing the user executing this resolver, as parameters.
  • If the user does not have permission or the condition you check is not valid, you should throw an error.
  ...
  checkPermission (params, viewer) {
  // Check permissions or any condition here.
  // Throw an error if viewer is not allowed or conditions are not met.
  },
  ...

Mutation resolver​

Mutations are used to perform GraphQL mutations to create, update or delete documents of a collection over the database. notice the mutation: true property, which is used to make the distintion for different modules to use, like Autoform

import {resolver} from '@orion-js/resolvers'
import Examples from 'app/collections/Examples'
import Example from 'app/models/Example'

export default resolver({
  params: {
    parameter1: {
      type: String
    },
    parameter2: {
      type: String
    }
  },
  returns: Boolean,
  mutation: true,
  async resolve({parameter1, parameter2}, viewer) {
    const example = await Examples.findOne(parameter1)
    await example.update({$set: {parameter2: parameter2}})
    return true
  }
})

Paginated resolver​

info

Paginated resolver, required install @orion-js/paginated-mongodb package.

Install package​

npm install @orion-js/paginated-mongodb

paginatedResolvers are used to get MongoDB cursors for a GraphQL Query, into a paginated list. Notice the async getCursor() function with respect to the async resolve() function in the basicResolver.

import {paginatedResolver} from '@orion-js/paginated-mongodb'
import Example from 'app/models/Example'
import Examples from 'app/collections/Examples'

export default paginatedResolver({
  params: {},
  returns: Example,
  async getCursor(params, viewer) {
    return Examples.find()
  }
})

paginatedResolvers also can receive parameters like in resolver:

import {paginatedResolver} from '@orion-js/paginated-mongodb'
import Example from 'app/models/Example'
import Examples from 'app/collections/Examples'

export default paginatedResolver({
  params: {
    parameter1: {
      type: String
    }
  },
  returns: Example,
  async getCursor({parameter1}, viewer) {
    return Examples.find(parameter1)
  }
})