Version: 0.14.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
});

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');
});