Version: 0.16.x

Adding Graphback to your project

Graphback can easily be added to your existing Apollo GraphQL Node.js application.

Let's take a look at a very simple, minimal Apollo GraphQL server setup.

import express from 'express';
import { ApolloServer } from 'apollo-server-express';
 
const app = express();
 
const schema = `
type Note {
  id: ID!
  text: String!
  archived: Boolean!
}

type Query {
  getAllNotes(): [Note]!
}
`

const noteResolvers = {
  Query: {
    getAllNotes: (parent, args, context) => {
      return context.db.getAllNotes();
    }
  }
}
 
const server = new ApolloServer({
  typeDefs: schema,
  resolvers: noteResolvers
});
 
server.applyMiddleware({ app });
 
app.listen({ port: 4000 }, () => {
  console.log('Apollo Server on http://localhost:4000/graphql');
});

In just a few short steps, Graphback can be added to this project.

Configure your database#

For this example we are going to assume that the project uses a PostgreSQL database.

To use PostgreSQL with Graphback install Knex.js with the Graphback PostgreSQL library:

npm install knex @graphback/runtime-knex

Once installed, initialize a Knex client using your database credentials, and create a Knex database provider creator for Graphback:

import Knex from 'knex';
import { createKnexDbProvider } from '@graphback/runtime-knex';

const knex = Knex({
  client: 'pg',
  connection: {
    host: '127.0.0.1',
    user: 'your_db_user',
    password: 'your_db_password',
    database: 'your_app_db'
  }
})

const knexProviderCreator = createKnexDbProvider(knex);

For more on database support in Graphback, see Databases.

Configure your schema#

Graphback will only process GraphQL types which are annotated with @model. This opt-in model enables you to combine Graphback enabled types and resolvers with your existing types that do not require bootstrapping.

In this scenario, we want Note to be processed by Graphback.

"""
@model
"""
type Note {
  id: ID!
  text: String!
  archived: Boolean!
}

For more advanced usage on how to configure your data models, see our Model guides.

Configure Graphback#

Let's install Graphback and use it in the project.

npm install graphback

buildGraphbackAPI will process your schema and generate a CRUD API with schema, resolvers, services and data sources.

import { buildGraphbackAPI } from 'graphback';

const { typeDefs, resolvers, contextCreator } = buildGraphbackAPI(schema, {
  dataProviderCreator: knexDbProviderCreator
});

Graphback automatically creates a CRUDService with default configuration values. You can override this with the serviceCreator option:

import { buildGraphbackAPI, createCRUDService } from 'graphback';
import { RedisPubSub } from 'graphql-redis-subscriptions';

const { typeDefs, resolvers, contextCreator } = buildGraphbackAPI(schema, {
  serviceCreator: createCRUDService({ pubSub: new RedisPubSub() }),
  ...
});

Check out the buildGraphbackAPI for more advanced use cases like CRUD configuration and plugin extensions.

Finish setup#

Now that you have added all the Graphback code, let's bring it together and add Graphback to your Apollo GraphQL server:

import express from 'express';
import http from "http";
import { ApolloServer } from 'apollo-server-express';
import { buildGraphbackAPI } from 'graphback'
import { createKnexDbProvider } from '@graphback/runtime-knex'

const app = express();
 
const schema = `
"""
@model
"""
type Note {
  id: ID!
  text: String!
  archived: Boolean!
}

type Query {
  getAllNotes(): [Note]!
}
`

// create a Knex client
const knex = Knex({
  client: 'pg',
  connection: {
    host: '127.0.0.1',
    user: 'your_db_user',
    password: 'your_db_password',
    database: 'your_app_db'
  }
});

// create a Knex database provider creator
const knexDbProviderCreator = createKnexDbProvider(knex);

// creates a schema, CRUD resolvers, services and data providers
const { typeDefs, resolvers, contextCreator } = buildGraphbackAPI(schema, {
  dataProviderCreator: knexDbProviderCreator
});

const server = new ApolloServer({
  typeDefs, // your schema as a string
  resolvers: [resolvers, noteResolvers], // merge Graphback resolvers with your own
  context: contextCreator // creates a context with Graphback services attached
});

server.applyMiddleware({ app });

const httpServer = http.createServer(app)
apolloServer.installSubscriptionHandlers(httpServer)
 
app.listen({ port: 4000 }, () => {
  console.log('Apollo Server on http://localhost:4000/graphql');
});