ejemplos - graphql postgresql
Cómo conectar GraphQL y PostgreSQL (6)
Eche un vistazo a graphql-sequelize para saber cómo trabajar con Postgres.
Para las mutaciones (crear / actualizar / eliminar) puede ver los ejemplos en el repositorio de retransmisión, por ejemplo.
GraphQL tiene mutaciones, Postgres tiene INSERT; GraphQL tiene consultas, Postgres tiene SELECT; etc., etc. No he encontrado un ejemplo que muestre cómo se pueden usar ambos en un proyecto, por ejemplo, pasar todas las consultas desde el front-end (React, Relay) en GraphQL, pero almacenar los datos en Postgres.
¿Alguien sabe lo que Facebook está usando como base de datos y cómo está conectado con GraphQL?
¿Es la única opción de almacenamiento de datos en Postgres en este momento construir "adaptadores" personalizados que tomen la consulta GraphQL y la conviertan en SQL?
GraphQL es independiente de la base de datos, por lo que puede usar lo que normalmente usa para interactuar con la base de datos, y usar el método de resolve búsqueda o mutación para llamar a una función que ha definido que obtendrá / agregará algo a la base de datos.
Sin relé
Aquí hay un ejemplo de una mutación usando el generador de consultas Knex SQL basado en promesas , primero sin relé para tener una idea del concepto. Voy a suponer que ha creado un userType en su esquema GraphQL que tiene tres campos: id , username y created : todo requerido, y que tiene una función getUser ya definida que consulta la base de datos y devuelve un objeto de usuario. En la base de datos también tengo una columna de password , pero como no quiero que me userType dejo fuera de mi userType .
// db.js
// take a user object and use knex to add it to the database, then return the newly
// created user from the db.
const addUser = (user) => (
knex(''users'')
.returning(''id'') // returns [id]
.insert({
username: user.username,
password: yourPasswordHashFunction(user.password),
created: Math.floor(Date.now() / 1000), // Unix time in seconds
})
.then((id) => (getUser(id[0])))
.catch((error) => (
console.log(error)
))
);
// schema.js
// the resolve function receives the query inputs as args, then you can call
// your addUser function using them
const mutationType = new GraphQLObjectType({
name: ''Mutation'',
description: ''Functions to add things to the database.'',
fields: () => ({
addUser: {
type: userType,
args: {
username: {
type: new GraphQLNonNull(GraphQLString),
},
password: {
type: new GraphQLNonNull(GraphQLString),
},
},
resolve: (_, args) => (
addUser({
username: args.username,
password: args.password,
})
),
},
}),
});
Dado que Postgres crea el id para mí y calculo la marca de tiempo created , no los necesito en mi consulta de mutación.
La forma de retransmisión
Usar los ayudantes en graphql-relay y graphql-relay muy cerca del Relay Starter Kit me ayudó, porque era mucho para graphql-relay todo de una vez. El relevo requiere que configure su esquema de una manera específica para que funcione correctamente, pero la idea es la misma: use sus funciones para buscar o agregar a la base de datos en los métodos de resolución.
Una advertencia importante es que el modo Relay espera que el objeto devuelto por getUser sea una instancia de un User clase, por lo que deberá modificar getUser para acomodar eso.
El último ejemplo que usa Relay ( fromGlobalId , globalIdField , mutationWithClientMutationId , y nodeDefinitions son todos de graphql-relay ):
/**
* We get the node interface and field from the Relay library.
*
* The first method defines the way we resolve an ID to its object.
* The second defines the way we resolve an object to its GraphQL type.
*
* All your types will implement this nodeInterface
*/
const { nodeInterface, nodeField } = nodeDefinitions(
(globalId) => {
const { type, id } = fromGlobalId(globalId);
if (type === ''User'') {
return getUser(id);
}
return null;
},
(obj) => {
if (obj instanceof User) {
return userType;
}
return null;
}
);
// a globalId is just a base64 encoding of the database id and the type
const userType = new GraphQLObjectType({
name: ''User'',
description: ''A user.'',
fields: () => ({
id: globalIdField(''User''),
username: {
type: new GraphQLNonNull(GraphQLString),
description: ''The username the user has selected.'',
},
created: {
type: GraphQLInt,
description: ''The Unix timestamp in seconds of when the user was created.'',
},
}),
interfaces: [nodeInterface],
});
// The "payload" is the data that will be returned from the mutation
const userMutation = mutationWithClientMutationId({
name: ''AddUser'',
inputFields: {
username: {
type: GraphQLString,
},
password: {
type: new GraphQLNonNull(GraphQLString),
},
},
outputFields: {
user: {
type: userType,
resolve: (payload) => getUser(payload.userId),
},
},
mutateAndGetPayload: ({ username, password }) =>
addUser(
{ username, password }
).then((user) => ({ userId: user.id })), // passed to resolve in outputFields
});
const mutationType = new GraphQLObjectType({
name: ''Mutation'',
description: ''Functions to add things to the database.'',
fields: () => ({
addUser: userMutation,
}),
});
const queryType = new GraphQLObjectType({
name: ''Query'',
fields: () => ({
node: nodeField,
user: {
type: userType,
args: {
id: {
description: ''ID number of the user.'',
type: new GraphQLNonNull(GraphQLID),
},
},
resolve: (root, args) => getUser(args.id),
},
}),
});
Probablemente FB usando mongodb o nosql en back-end. Recientemente leí una entrada de blog que explica cómo conectarse a mongodb. Básicamente, necesita construir un modelo de gráfico para que coincida con los datos que ya tiene en su base de datos. Luego, escriba resolución, función de rechazo para decirle a GQL cómo comportarse al publicar una solicitud de consulta.
Ver https://www.compose.io/articles/using-graphql-with-mongodb/
Abordamos este problema en Join Monster , una biblioteca que hemos abierto recientemente para traducir automáticamente las consultas GraphQL a SQL en función de las definiciones de esquema.
Este Graphical Starter Kit se puede usar para experimentar con GraphQL.js y PostgreSQL:
https://github.com/kriasoft/graphql-starter-kit - Node.js, GraphQL.js, PostgreSQL, Babel, Flow
(descargo de responsabilidad: soy el autor)
Eche un vistazo a SequelizeJS, que es un ORM basado en promesas que puede funcionar con varios dialectos; PostgreSQL, MySQL, SQLite y MSSQL
El siguiente código se saca directamente de su ejemplo
const Sequelize = require(''sequelize'');
const sequelize = new Sequelize(''database'', ''username'', ''password'', {
host: ''localhost'',
dialect: ''mysql''|''sqlite''|''postgres''|''mssql'',
pool: {
max: 5,
min: 0,
acquire: 30000,
idle: 10000
},
// SQLite only
storage: ''path/to/database.sqlite'',
// http://docs.sequelizejs.com/manual/tutorial/querying.html#operators
operatorsAliases: false
});
const User = sequelize.define(''user'', {
username: Sequelize.STRING,
birthday: Sequelize.DATE
});
sequelize.sync()
.then(() => User.create({
username: ''janedoe'',
birthday: new Date(1980, 6, 20)
}))
.then(jane => {
console.log(jane.toJSON());
});