graphql-schema-sushi v1.2.6

graphql-schema-sushi

• recompose-schema
  • new GraphQLField()
  • withAfterware()
  • withArgs()
  • withAuthentication()
  • withConnection()
  • withCursorPagination()
  • withFilter()
  • withMiddleware()
  • withMutation()
  • withOffsetPagination()
  • withSubscription()

new GraphQLField()

use class extends

class Node extends GraphQLField {
  type = null;

  args = {};

  description = null;

  deprecationReason = null;

  resolve = null;

  subscribe = null;
}

use new object

new GraphQLField({
  name: "Node",
  type: null,
  args: {},
  description: null,
  deprecationReason: null,
  resolve: null,
  subscribe: null,
});

withAfterware()

const field = new GraphQLField();
function handler(source, args, context, info, results) {
  return newResults; // use original results when no return
}
export default field |> withAfterware(handler);

withArgs()

handler mode

const field = new GraphQLField({
 // will get original args and handler replies
 resolve: (source, { ...args, ...replies }, context, info, results) {}
});
function handler(source, args, context, info) {
  return replies;
}
export default field |> withArgs(handler);

static object

const field = new GraphQLField({
 // will get original args and { id: 50 }
 resolve: (source, { ...args, ...{ id: 50 } }, context, info, results) {}
});
export default field |> withArgs({ id: 50 });

withAuthentication()

const field = new GraphQLField();
// throw new error when context.auth.user is null or undefined
export default field
  |> withArgs({
    error: AuthenticationError,
  });

withConnection()

// QueryNodes.js
const field = new GraphQLField({
  name: "Nodes",
  type: GraphQLInt,
});
export default field |> withConnection();

// Schema.js
import QueryNodes from "./QueryNodes";
new GraphQLSchema({
  query: new GraphQLObjectType({
    name: "Query",
    fields: () => ({
      nodes: QueryNodes,
    }),
  }),
});

output

type Query {
  nodes: [Int]
}

withCursorPagination()

// QueryNodes.js
const dataSource = {
  fetchPage({ after, first }) {
    return _.assign([...nodes], { totalCount, hasNextPage });
  }
}
const field = new GraphQLField({
  name: 'Nodes',
  type: GraphQLInt
  resolve() { return dataSource; }
});
export default field |> withCursorPagination();

// Schema.js
import QueryNodes from './QueryNodes';
new GraphQLSchema({
  query: new GraphQLObjectType({
    name: "Query",
    fields: () => ({
      nodes: QueryNodes,
    }),
  }),
});

output

type NodesEdge {
  cursor: ID
  node: Int
}

type PageInfo {
  endCursor: ID
  hasNextPage: Boolean
}

type Nodes {
  totalCount: Int
  edges: [NodesEdge]
  pageInfo: PageInfo
}

type Query {
  nodes(first: Int, after: ID): Nodes
}

withFilter()

const field = new GraphQLField({
  name: "Node",
  type: GraphQLInt,
});
function handler(source, args, context, info) {
  return true; // will output null when no return or return false;
}
export default field |> withFilter(handler);

withMiddleware()

const field = new GraphQLField({
  name: "Node",
  type: GraphQLInt,
});
function handler(source, args, context, info) {
  return [source, args, context, info]; // use original data when no return
}
export default field |> withMiddleware(handler);

withMutation()

// UpdateNodeMutation.js
const field = new GraphQLField({
  name: 'Node',

  // input fields
  args: {
    id: { type: ID },
  }

  // output fields
  type: {
    status: { type: GraphQLBoolean },
    node: { type: GraphQLInt },
  },

  resolve: () => {}
});
export default field |> withMutation();

// Schema.js
import UpdateNodeMutation from './UpdateNodeMutation';
new GraphQLSchema({
  mutation: new GraphQLObjectType({
    name: "Mutation",
    fields: () => ({
      updateNode: UpdateNodeMutation,
    }),
  }),
});

output

input NodeInput {
  id: ID
}

type NodePayload {
  status: GraphQLBoolean
  node: GraphQLInt
}

type Mutation {
  updateNode(input: NodeInput!): NodePayload
}

withOffsetPagination()

// QueryNodes.js
const dataSource = {
  fetchPage({ offset, first }) {
    return _.assign([...nodes], { totalCount });
  }
}
const field = new GraphQLField({
  name: 'Nodes',
  type: GraphQLInt
  resolve() { return dataSource; }
});
export default field |> withOffsetPagination();

// Schema.js
import QueryNodes from './QueryNodes';
new GraphQLSchema({
  query: new GraphQLObjectType({
    name: "Query",
    fields: () => ({
      nodes: QueryNodes,
    }),
  }),
});

type Nodes {
  totalCount: Int
  nodes: [Int]
}

type Query {
  nodes(first: Int, offset: Int): Nodes
}