Neptune's Personal Maid

    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

    14

    Version

    3.0.0-alpha.5

    License

    MIT

    Unpacked Size

    928 kB

    Total Files

    602

    Last publish

    Collaborators

    • vbranden