Relations d’entité dans le générateur d’API de données

Les relations d’entité permettent aux requêtes GraphQL de parcourir les entités associées, ce qui permet d’activer des formes de données complexes avec une seule requête. Par exemple:

{
  books {
    items {
      id
      title
      authors {
        items {
          first_name
          last_name
        }
      }
    }
  }
}

Pour ce faire, DAB doit être informé de la façon dont les entités sont associées via la relationships section du fichier de configuration.

Paramétrage

Pour définir une relation entre les entités :

• Utilisez l’objet relationships à l’intérieur de la configuration de l’entité.
• Indiquez le target.entity nom.
• Définir cardinality en tant que "one" ou "many".
• Si vous le souhaitez, spécifiez source.fields et target.fields.
• Utilisez cette option linking.object pour modéliser des relations plusieurs-à-plusieurs sans exposer la table de jointure.

Exemple CLI

dab update Book \
  --relationship authors \
  --target.entity Author \
  --cardinality many \
  --relationship.fields "id:id" \
  --linking.object "dbo.books_authors" \
  --linking.source.fields "book_id" \
  --linking.target.fields "author_id"

Exemple de configuration

"Book": {
  "source": "dbo.books",
  "relationships": {
    "authors": {
      "cardinality": "many",
      "target.entity": "Author",
      "source.fields": [ "id" ],
      "target.fields": [ "id" ],
      "linking.object": "dbo.books_authors",
      "linking.source.fields": [ "book_id" ],
      "linking.target.fields": [ "author_id" ]
    }
  }
}

Un-à-plusieurs

• Utilisez la cardinalité "many".
• Exemple : un Series a de nombreux Books.
• DAB peut déduire des champs si une clé étrangère existe.

dab update Series \
  --relationship books \
  --target.entity Book \
  --cardinality many

Plusieurs à un

• Utilisez la cardinalité "one".
• Exemple : A Book appartient à un Series.

dab update Book \
  --relationship series \
  --target.entity Series \
  --cardinality one

Plusieurs à plusieurs (objet de liaison)

• Utilisez une table de jointure qui n’est pas exposée dans GraphQL.
• Définissez les champs de liaison de la source à la cible via la table de jointure.

dab update Author \
  --relationship books \
  --target.entity Book \
  --cardinality many \
  --relationship.fields "id:id" \
  --linking.object "dbo.books_authors" \
  --linking.source.fields "author_id" \
  --linking.target.fields "book_id"

Plusieurs à plusieurs (entité de jointure explicite)

• Exposez la table de jointure en tant qu’objet GraphQL.
• Définissez des relations sur les trois entités.

dab add BookAuthor \
  --source dbo.books_authors \
  --permissions "anonymous:*"

dab update BookAuthor \
  --relationship book \
  --target.entity Book \
  --cardinality one \
  --relationship.fields "book_id:id"

dab update BookAuthor \
  --relationship author \
  --target.entity Author \
  --cardinality one \
  --relationship.fields "author_id:id"

Relations réciproques

Pour autoriser la navigation dans les deux directions (par exemple, de Book vers Author et de Author vers Book), définissez une deuxième relation sur l’entité cible qui intervertit les champs source et cible.

Exemple :

dab update Author \
  --relationship books \
  --target.entity Book \
  --cardinality many \
  --relationship.fields "id:id" \
  --linking.object "dbo.books_authors" \
  --linking.source.fields "author_id" \
  --linking.target.fields "book_id"

Cela s'associe avec la relation entre Book et Author et active la traversée symétrique dans GraphQL.

{
  authors {
    items {
      first_name
      books {
        items {
          title
        }
      }
    }
  }
}

Prise en charge de GraphQL

• Les champs associés apparaissent sous forme d’objets imbriqués.
• La cardinalité détermine si une liste ou un objet unique est retourné.
• Les noms de type GraphQL et les champs correspondent aux noms de configuration.

Limites

• Les relations nécessitent l’existence d’entités dans le même fichier de configuration.
• Seule la navigation à un seul saut est prise en charge.
• Les cycles et les imbrications complexes ne sont pas optimisés.
• REST ne prend pas en charge les relations (GraphQL uniquement).