El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Conceptes bàsics de l'esquema de GraphQL

Següent ►
►

En aquest tema, aprendrem els conceptes fonamentals de l'esquema de GraphQL. L'esquema és el cor de qualsevol servidor GraphQL, ja que defineix la forma de les dades i les operacions que es poden realitzar sobre aquestes dades.

Continguts

  1. Què és un esquema de GraphQL?
  2. Definició de tipus
  3. Consultes i Mutacions
  4. Resolvers
  5. Exemple pràctic
  6. Exercicis

Què és un esquema de GraphQL?

Un esquema de GraphQL és una descripció de les capacitats d'una API GraphQL. Defineix:

  • Els tipus d'objectes que es poden consultar.
  • Les relacions entre aquests objectes.
  • Les operacions disponibles (consultes, mutacions i subscripcions).

Definició de tipus

Els tipus són la base de l'esquema de GraphQL. Hi ha diversos tipus que podem definir:

Tipus d'objecte

Els tipus d'objecte defineixen les estructures de dades que es poden consultar. Per exemple:

type User {
  id: ID!
  name: String!
  email: String!
}

Tipus d'entrada

Els tipus d'entrada s'utilitzen per passar arguments a les mutacions. Per exemple:

input CreateUserInput {
  name: String!
  email: String!
}

Tipus d'enumeració

Els tipus d'enumeració defineixen un conjunt de valors possibles per a un camp. Per exemple:

enum Role {
  ADMIN
  USER
  GUEST
}

Consultes i Mutacions

Consultes

Les consultes són operacions que permeten recuperar dades. Es defineixen en el tipus Query. Per exemple:

type Query {
  users: [User!]!
  user(id: ID!): User
}

Mutacions

Les mutacions són operacions que permeten modificar dades. Es defineixen en el tipus Mutation. Per exemple:

type Mutation {
  createUser(input: CreateUserInput!): User!
}

Resolvers

Els resolvers són funcions que proporcionen les dades per als camps de l'esquema. Cada camp en un tipus d'objecte pot tenir un resolver associat. Per exemple:

const resolvers = {
  Query: {
    users: () => {
      // Retorna una llista d'usuaris
    },
    user: (parent, args) => {
      // Retorna un usuari per ID
    },
  },
  Mutation: {
    createUser: (parent, args) => {
      // Crea un nou usuari
    },
  },
};

Exemple pràctic

A continuació, veurem un exemple complet d'un esquema de GraphQL amb tipus, consultes, mutacions i resolvers.

Esquema

type User {
  id: ID!
  name: String!
  email: String!
}

input CreateUserInput {
  name: String!
  email: String!
}

type Query {
  users: [User!]!
  user(id: ID!): User
}

type Mutation {
  createUser(input: CreateUserInput!): User!
}

Resolvers

const users = [];

const resolvers = {
  Query: {
    users: () => users,
    user: (parent, args) => users.find(user => user.id === args.id),
  },
  Mutation: {
    createUser: (parent, args) => {
      const newUser = { id: users.length + 1, ...args.input };
      users.push(newUser);
      return newUser;
    },
  },
};

module.exports = resolvers;

Exercicis

Exercici 1: Afegir un camp nou

Afegiu un camp age al tipus User i actualitzeu les consultes i mutacions per gestionar aquest nou camp.

Exercici 2: Crear una mutació de supressió

Creeu una mutació deleteUser que permeti suprimir un usuari per ID.

Solucions

Solució a l'Exercici 1

Actualització de l'esquema:

type User {
  id: ID!
  name: String!
  email: String!
  age: Int
}

input CreateUserInput {
  name: String!
  email: String!
  age: Int
}

Actualització dels resolvers:

const resolvers = {
  Query: {
    users: () => users,
    user: (parent, args) => users.find(user => user.id === args.id),
  },
  Mutation: {
    createUser: (parent, args) => {
      const newUser = { id: users.length + 1, ...args.input };
      users.push(newUser);
      return newUser;
    },
  },
};

Solució a l'Exercici 2

Actualització de l'esquema:

type Mutation {
  createUser(input: CreateUserInput!): User!
  deleteUser(id: ID!): User
}

Actualització dels resolvers:

const resolvers = {
  Query: {
    users: () => users,
    user: (parent, args) => users.find(user => user.id === args.id),
  },
  Mutation: {
    createUser: (parent, args) => {
      const newUser = { id: users.length + 1, ...args.input };
      users.push(newUser);
      return newUser;
    },
    deleteUser: (parent, args) => {
      const userIndex = users.findIndex(user => user.id === args.id);
      if (userIndex === -1) return null;
      const deletedUser = users.splice(userIndex, 1);
      return deletedUser[0];
    },
  },
};

Conclusió

En aquest tema, hem après els conceptes bàsics de l'esquema de GraphQL, incloent-hi la definició de tipus, consultes, mutacions i resolvers. Aquests conceptes són fonamentals per construir una API GraphQL robusta i eficient. En el proper mòdul, aprofundirem en les consultes i mutacions, explorant com es poden utilitzar per interactuar amb les dades.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats