Ready to take your JavaScript development to the next level? Meet npm Enterprise - the ultimate in enterprise JavaScript. Learn more »

graphql-factory

3.0.0-alpha.5 • Public • Published

graphql-factory

Tools for building GraphQL

Announcements

  • Alpha releases have started...

  • Documentation on graphqlfactory.io is not currently up to date. This announcement will be removed when it is.

This project is currently undergoing a major re-write for v3.0.0. This will include

  • a more graphql-like api
  • updated GraphQL Factory Definition Format
  • custom execution which will allow
    • custom directive middleware support
    • tracing data for all resolves/middleware
  • Schema building tools
  • Schema language support
  • better code testing
  • and more...

v2.1.0 code is available in the v2.1.0 branch. The master branch will be used for v3.0.0 development

Schema Language Example

Create a schema from schema language and a SchemaBacking

import { graphql } from 'graphql'
import {
  SchemaDefinition,
  SchemaBacking
} from 'graphql-factory'
 
// create a schema language definition
const definition = `
  type Item {
    id: String!
    name: String!
  }
 
  type List {
    id: String!
    name: String!
    items: [Item]!
  }
 
  type Query {
    listLists (search: String): [List]
  }
 
  directive @test(value: String) on SCHEMA | OBJECT | QUERY | FIELD
 
  schema @test(value: "I am a schema directive") {
    query: Query
  }`
 
// create a schema backing that contains resolvers
const backing = new SchemaBacking()
  .Directive('test')
    .resolve((source, args, context, info) => {
      console.log('Testing', args)
    })
  .Object('Query')
    .resolve('listLists', (source, args, context, info) => {
      // resolve code
    })
  .Object('List')
    .resolve('items', (source, args, context, info) => {
      // resolve code
    })
  .backing()
 
// create an async function so we can use await
async function main() {
  // build a schema from the definition and backing
  const schema = await new SchemaDefinition()
    .use(definition, backing)
    .buildSchema()
 
  // make a request with the attached request method
  // you can also use the standard graphql execution
  // but extensions will not be returned in the result
  const result = await schema.request({
    source: `
      query MyQuery {
        listLists {
          name
          items {
            name
          }
        }
      }
    `
  });
 
  console.log(result);
}
 
// call async function to execute query
main();

Factory Definition Example

Create the same schema using GraphQL Factory Definition Format

import { graphql } from 'graphql'
import { SchemaDefinition } from 'graphql-factory'
 
// graphql factory definition which includes
// definitions and resolvers
const definition = {
  directives: {
    test: {
      locations: [ 'SCHEMA', 'OBJECT', 'QUERY', 'FIELD' ],
      args: {
        value: { type: 'String' }
      },
      resolve (source, args, context, info) {
        console.log('Testing', args)
      }
    }
  },
  types: {
    Item: {
      type: 'Object',
      fields: {
        id: { type: 'String!' },
        name: { type: 'String!' }
      }
    },
    List: {
      type: 'Object',
      fields: {
        id: { type: 'String!' },
        name: { type: 'String!' },
        items: {
          type: '[Item]!',
          resolve(source, args, context, info) {
            // resolve code
          }
        }
      }
    },
    Query: {
      type: 'Object',
      fields: {
        listLists: {
          type: '[List]',
          args: {
            search: { type: 'String' }
          },
          resolve(source, args, context, info) {
            // resolve code
          }
        }
      }
    }
  },
  schema: {
    directives: [ 'test' ],
    query: 'Query',
    '@directives': {
      test: {
        value: 'I am a schema directive'
      }
    }
  }
}
 
// create an async function so we can use await
async function main() {
  // build a schema from the definition and backing
  const schema = await new SchemaDefinition()
    .use(definition)
    .buildSchema()
 
  // make a request with the attached request method
  // you can also use the standard graphql execution
  // but extensions will not be returned in the result
  const result = await schema.request({
    source: `
      query MyQuery {
        listLists {
          name
          items {
            name
          }
        }
      }
    `
  });
 
  console.log(result);
}
 
// call async function to execute query
main();

install

npm i graphql-factory

Downloadsweekly downloads

111

version

3.0.0-alpha.5

license

MIT

homepage

github.com

repository

Gitgithub

last publish

collaborators

  • avatar
Report a vulnerability