PostgREST, mettre en place une API RestFull depuis n'importe quelle base de données PostgreSQL

Gérard Ernaelsten

PostgREST est un serveur Web autonome qui transforme votre base de données PostgreSQL directement en une API RESTful

Pour réagir au contenu de cet article, un espace de dialogue vous est proposé sur le forum. Commentez .

- Titre : PostgREST, mettre en place une API RestFull depuis n'importe quelle base de données PostgreSQL

- Auteur : Gérard Ernaelsten

- Parution : 12 décembre 2019

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2019 MaitrePylos. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. PostgREST API pour PostgreSQL

- I-A. Schéma de base de données

- I-B. Installation

- I-C. Premiers pas

- I-D. Qui fait quoi ?

- I-D-1. Complexifions nos requêtes

- I-D-2. Jointure de tables (embedded)

- I-D-3. Multi jointure de tables

- I-D-4. Pagination

- I-E. Insertion

- I-F. Delete

- I-G. Update

- I-H. REST Classique et Https

- II. Swagger

- III. Authentification JWT

- III-A. Principe de base

- III-A-1. Installation extension jwt PostgreSQL

- III-A-2. Activation des extensions dans PostgreSQL

- III-A-3. Mise en place des processus JWT

- III-A-4. Login

- IV. Http-Client Symfony

- V. Conclusion

- VI. Remerciments

I - PostgREST API pour PostgreSQL

PostgREST est un serveur Web autonome qui transforme votre base de données PostgreSQL directement en une API RESTful. Les contraintes structurelles et les autorisations dans la base de données déterminent les points de terminaison et les opérations de l'API. PostgREST permet d'exposer une base de données PostgreSQL sous forme d'API REST directement consommables par des applications mobiles, des portails Web ou bien des partenaires.

PostgREST sert une API entièrement RESTful à partir de tout type de base de données PostgreSQL existante. Selon l’équipe de développement, PostgREST fournit une API plus propre, plus conforme aux normes et plus rapide que celle que vous êtes susceptible d'écrire à partir de zéro. Elle estime que son utilisation est une alternative à la programmation manuelle CRUD. PostgREST est un middleware open source et les API exposées par PostgREST sont conformes à la spécification OpenAPI (anciennement connue sous le nom de spécification Swagger)." (Source : PostgREST : un serveur Web autonome qui transforme une base de données PostgreSQL, Bill Fassinou)

Cet article n'a pour objectif que de vous montrer comment je fais pour mettre en place PostgREST.

Vous trouverez plus d'informations sur la documentation officielle de PostgREST.

I-A - Schéma de base de données

Je pars du principe que vous disposez d'une instance PostgreSQL, pour enrichir les exemples, je vais installer la base de données SAKILA, que nous pouvons trouver sur GitHub.

Nous travaillerons sur quelques tables :

I-B - Installation

L'installation de PostgRESt se fait très facilement, il est possible d'utiliser un binaire pour :

- CentOS

- Ubuntu

- FreeBsd

- OSX

- Windows

Nous avons également la possibilité d'avoir accès aux sources et de disposer d’une image Docker.

C'est cette dernière que nous utiliserons pour l'installation de notre exemple.

Vous trouverez l'image officielle sur le docker hub.

Avant toute chose, nous allons définir un rôle qui peut faire des select dans la base de données. En effet, il n'est pas question d'utiliser le rôle postgres.

1. -- création du rôle

2. create role anonymous nologin;

3. -- usage du schéma public

4. grant usage on schema public to anonymous;

5. -- donne le droit select aux tables qui nous intéressent

6. grant select on public.film to anonymous;

7. grant select on public.film_actor to anonymous;

8. grant select on public.actor to anonymous;

9. grant select on public.film_category to anonymous;

10. grant select on public.category to anonymous;

11. grant select on public.language to anonymous;

12. grant select on public.actor_info to anonymous;

Nous avons maintenant un rôle qui va pouvoir faire nos requêtes (select). Nous allons donc créer un rôle capable de se connecter à notre base de données.

1. -- création du rôle authenticator

2. create role authenticator noinherit login password 'mysecretpassword';

3. -- accès des droits de authenticator sur anonymous

4. grant anonymous to authenticator;

On en profite pour ajouter quelques droits qui nous serviront plus tard pour insert/update et delete.

1. -- insert dans la table film

2. GRANT INSERT ON TABLE public.film TO anonymous;

3. -- update dans la table film

4. GRANT UPDATE ON TABLE public.film TO anonymous;

5. -- delete dans la table film_actor

6. GRANT DELETE ON TABLE public.film_actor TO anonymous;

7. -- on ajoute également les droits à la séquence pour l'autoincrement

8. GRANT SELECT ON SEQUENCE public.film_film_id_seq TO anonymous;

9. GRANT UPDATE ON SEQUENCE public.film_film_id_seq TO anonymous;

10. GRANT USAGE ON SEQUENCE public.film_film_id_seq TO anonymous;

Maintenant que l'on peut se connecter à la base de données, nous allons lancer notre api via docker-compose.

Nous devons fournir un fichier de configuration avec notre instance PostgREST, voici les directives :

Name

Type

Default

Required

db-uri

String

Y

db-schema

String

Y

db-anon-role

String

Y

db-pool

Int

10

db-pool-timeout

Int

10

db-extra-search-path

String

public

server-host

String

!4

server-port

Int

3000

server-unix-socket

String

server-proxy-uri

String

jwt-secret

String

jwt-aud

String

secret-is-base64

Bool

False

max-rows

Int

?

pre-request

String

app.settings.*

String

role-claim-key

String

.role

raw-media-types

String

En Docker, toutes ces directives sont passées grâce à des variables d’environnement avec la nomenclature PGRST_DIRECTIVE_MAJUSCULE.

Trois directives sont obligatoires.

Voici un fichier yaml de base, dans lequel nous gardons nos informations sur une ip localhost.

1. # docker-compose.yml

3. version: '3'

4. services:

5. server:

6. image: postgrest/postgrest

7. ports:

8. - "3000:3000"

9. environment:

10. PGRST_DB_URI: postgres://authenticator:mysecretpassword@localhost:5432/film

11. PGRST_DB_SCHEMA: public

12. PGRST_DB_ANON_ROLE: anonymous

13. network_mode: host

On crée notre instance Docker :

1. docker-compose up --no-start

2. Recreating postgrest_server_1 ...

3. Recreating postgrest_server_1 ... done

On lance notre instance :

1. docker-compose start

2. Starting server ... done

Nous pouvons utiliser notre API.

I-C - Premiers pas

L'utilisation est très simple et en même temps, cela demande un peu de réflexion au départ.

La première requête que nous allons faire est d’accéder à notre API sur sa racine :

1. http://localhost:3000

Cette adresse retourne la documentation (OpenApi), qui pourra être traduite par Swagger (dont on parle plus bas), pour afficher une documentation automatique de notre API.

Bon à savoir : si vous enregistrez cette documentation dans un fichier.json, vous pourrez l'exporter dans un outil comme PostMan ou InsomniaRest ce qui créera automatiquement toutes les requêtes possibles.

Lançons notre première requête :

1. select * from film

cette requête au format API est très simple :

1. http://localhost:3000/film

Cela va nous retourner un json de l'ensemble de la table film, voici un exemple de sortie :

1. [

2. {

3. "film_id": 1,

4. "title": "ACADEMY DINOSAUR",

5. "description": "A Epic Drama of a Feminist And a Mad Scientist who must Battle a Teacher in The Canadian Rockies",

6. "release_year": 2006,

7. "language_id": 1,

8. "original_language_id": null,

9. "rental_duration": 6,

10. "rental_rate": 0.99,

11. "length": 86,

12. "replacement_cost": 20.99,

13. "rating": "PG",

14. "last_update": "2006-02-15T05:03:42",

15. "special_features": [

16. "Deleted Scenes",

17. "Behind the Scenes"

18. ],

19. "fulltext": "'academi':1 'battl':15 'canadian':20 'dinosaur':2 'drama':5 'epic':4 'feminist':8 'mad':11 'must':14 'rocki':21 'scientist':12 'teacher':17"

20. },

21. {

22. "film_id": 2,

23. "title": "ACE GOLDFINGER",

24. "description": "A Astounding Epistle of a Database Administrator And a Explorer who must Find a Car in Ancient China",

25. "release_year": 2006,

26. "language_id": 1,

27. "original_language_id": null,

28. "rental_duration": 3,

29. "rental_rate": 4.99,

30. "length": 48,

31. "replacement_cost": 12.99,

32. "rating": "G",

33. "last_update": "2006-02-15T05:03:42",

34. "special_features": [

35. "Trailers",

36. "Deleted Scenes"

37. ],

38. "fulltext": "'ace':1 'administr':9 'ancient':19 'astound':4 'car':17 'china':20 'databas':8 'epistl':5 'explor':12 'find':15 'goldfing':2 'must':14"

39. }

40. ]

Normalement, on devrait y trouver beaucoup plus de données, mais j'ai limité celles-ci à 2 en passant le paramètre « limit »

en réalité j'ai fait ceci :

1. select * from film limit 2

Ce qui en route API donne :

1. http://localhost:3000/film?limit=2

On voit donc ici qu'on utilise les routes http classiques, avec le passage en paramètres des données grâce aux caractères « ? » (point d'interrogation) et « & » (esperluette).

Nous voulons récupérer les films qui ont une longueur de 117, nous devons alors filtrer notre requête sur l’attribut « length » :

1. select * from film where length = 177

Notre route serait alors :

1. http://localhost:3000/film?length=eq.117

Si on décortique cette route, la particularité est la discrimination sur l'attribut length.

1. length=eq.117

le signe '=' attribue bien la valeur eq.117 , en effet , on doit bien dire à PotgreSQL ce qu'il doit faire et c'est le sigle eq qui spécifie que PostgreSQL doit faire dans un where une égalité. Autrement dit, la longueur doit être égale à 117.

Ce système a été choisi afin de pouvoir lancer la plupart de nos choix.

Voici un tableau reprenant l'ensemble des équivalences :

Abbreviation

In PostgreSQL

Meaning

eq

=

equals

gt

>

greater than

gte

>=

greater than or equal

lt

<

less than

lte

<=

less than or equal

neq

<> or !=

not equal

like

LIKE

LIKE operator (use * in place of %)

ilike

ILIKE

ILIKE operator (use * in place of %)

in

IN

one of a list of values, e.g. ?a=in.(1,2,3) – also supports commas in quoted strings like ?a=in.("hi,there","yes,you")

is

IS

checking for exact equality (null,true,false)

fts

@@

Full-Text Search using to_tsquery

plfts

@@

Full-Text Search using plainto_tsquery

phfts

@@

Full-Text Search using phraseto_tsquery

wfts

@@

Full-Text Search using websearch_to_tsquery

cs

@>

contains e.g. ?tags=cs.{example, new}

cd

<@

contained in e.g. ?values=cd.{1,2,3}

ov

&&

overlap (have points in common), e.g. ?period=ov.[2017-01-01,2017-06-30] – also supports array types, use curly braces instead of square brackets e.g. :code: ?arr=ov.{1,3}

sl

<<

strictly left of, e.g. ?range=sl.(1,10)

sr

>>

strictly right of

nxr

&<

does not extend to the right of, e.g. ?range=nxr.(1,10)

nxl

&>

does not extend to the left of

adj

-|-

is adjacent to, e.g. ?range=adj.(1,10)

not

NOT

negates another operator, see below

I-D - Qui fait quoi ?

Comment PostgREST fait-il pour retourner le résultat en Json ? C'est PostgreSQL lui-même qui s'en charge. En effet les lead developers sont partis du constat que le moteur PostgreSQL est le mieux à même de gérer toutes ses requêtes et de les restituer dans leur ensemble. Nous verrons plus loin qu'il utilise ce principe jusqu’à la sécurité des utilisateurs.

Donc si j'appelle la route :

1. http://localhost:3000/film?length=eq.117

Voici ce que PostgREST envoie à PostgreSQL :

1. WITH pg_source AS (

2. SELECT "public"."film".*

3. FROM "public"."film"

4. WHERE  "public"."film"."length" = '117'::unknown

5. )

6. SELECT null AS total_result_set, pg_catalog.count(_postgrest_t) AS page_total,

7. array[]::text[] AS header,

8. coalesce(json_agg(_postgrest_t), '[]')::character varying AS body

9. FROM ( SELECT * FROM pg_source) _postgrest_t

Nous avons donc une CTE qui exécute notre requête et retourne le résultat sous forme de Json dans un attribut nommé body coalesce(json_agg(_postgrest_t), '[]')::character varying AS body

Ce mécanisme permet de faire l'abstraction d'une couche supplémentaire qu'un langage de programmation pourrait ajouter.

I-D-1 - Complexifions nos requêtes

Si l'on ne veut qu'une partie de l'information, il faut pouvoir sélectionner ce que nous désirons. Nous allons donc travailler avec le jeu de données dont le film_id est 374.

Si l'on veut récupérer le jeu de données complet, nous aurions une route assez simple :

1. http://localhost:3000/film?film_id=eq.374

Une autre possibilité est de lui définir explicitement que nous voulons tout :

1. http://localhost:3000/film?select=*&film_id=eq.374

Cet élément select va nous permettre de définir les attributs que nous désirons :

1. http://localhost:3000/film?select=title,description,last_update&film_id=eq.374

Ce que PostgREST génère comme requête dans ce cas est :

1. WITH pg_source AS (

2. SELECT "public"."film"."title", "public"."film"."description", "public"."film"."last_update"

3. FROM "public"."film"

4. WHERE  "public"."film"."film_id" = '374'::unknown

5. )

6. SELECT null AS total_result_set, pg_catalog.count(_post WITH pg_source AS (SELECT "public"."film"."title", "public"."film"."description", "public"."film"."last_update" FROM "public"."film"  WHERE  "public"."film"."film_id" = '374'::unknown   ) SELECT null AS total_result_set, pg_catalog.count(_postgrest_t) AS page_total, array[]::text[] AS header, coalesce(json_agg(_postgrest_t), '[]')::character varying AS body

7. FROM ( SELECT * FROM pg_source) _postgrest_tgrest_t) AS page_total,

8. array[]::text[] AS header,

9. coalesce(json_agg(_postgrest_t), '[]')::character varying AS body

10. FROM ( SELECT * FROM pg_source) _postgrest_t

On voit bien que cela sélectionne les attributs choisis.

Nous pouvons renommer nos attributs, il suffit de préfixer par : nouveauNom:atribut

1. http://localhost:3000/film?select=titre:title,chapeau:description,last_update&film_id=eq.374

1. [

2. {

3. "titre": "GRAFFITI LOVE",

4. "chapeau": "A Unbelieveable Epistle of a Sumo Wrestler And a Hunter who must Build a Composer in Berlin",

5. "last_update": "2006-02-15T05:03:42"

6. }

7. ]

Nous pouvons également caster nos valeurs, de la même façon que PostgreSQL caste :

Sans cast :

1. http://localhost:3000/film?select=rental_rate&film_id=eq.374

1. [

2. {

3. "rental_rate": 0.99

4. }

5. ]

Avec cast :

1. http://localhost:3000/film?select=rental_rate::text&film_id=eq.374

1. [

2. {

3. "rental_rate": "0.99"

4. }

5. ]

Si je veux rechercher le titre 'ANGELS LIFE', l'idéal sera d'utiliser le like en ajoutant de en lieu et place des %

1. http://localhost:3000/film?select=*&title=like.*ANGELS LIFE*

Mais nous pourrions aussi remplacer l'espace par comme la convention html nous le permet et utiliser une égalité au lieu du like :

1. http://localhost:3000/film?select=*&title=eq.ANGELS LIFE

Mais cela est beaucoup plus laborieux.

Nous pouvons bien sûr filtrer le tout sur plusieurs attributs :

1. http://localhost:3000/film?select=titre:title&length=eq.117&rental_duration=eq.3

1. [

2. {

3. "titre": "GRAFFITI LOVE"

4. },

5. {

6. "titre": "MAGIC MALLRATS"

7. }

8. ]

Je pense que nous avons bien compris le principe.

I-D-2 - Jointure de tables (embedded)

PostgREST se base sur les contraintes de foreign key définies dans la base de données pour faire les jointures naturelles des requêtes, ces jointures se font donc sur les clefs définies (qu'elles soient primaires (primary key) ou non).

La jointure s'organise dans le select en prenant en plus des attributs, le nom de la table à joindre. Exemple entre un film et sa langue :

1. http://localhost:3000/film?select=*,language(*)&limit=2

1. [

2. {

3. "film_id": 1,

4. "title": "ACADEMY DINOSAUR",

5. "description": "A Epic Drama of a Feminist And a Mad Scientist who must Battle a Teacher in The Canadian Rockies",

6. "release_year": 2006,

7. "language_id": 1,

8. "original_language_id": null,

9. "rental_duration": 6,

10. "rental_rate": 0.99,

11. "length": 86,

12. "replacement_cost": 20.99,

13. "rating": "PG",

14. "last_update": "2006-02-15T05:03:42",

15. "special_features": [

16. "Deleted Scenes",

17. "Behind the Scenes"

18. ],

19. "fulltext": "'academi':1 'battl':15 'canadian':20 'dinosaur':2 'drama':5 'epic':4 'feminist':8 'mad':11 'must':14 'rocki':21 'scientist':12 'teacher':17",

20. "language": {

21. "language_id": 1,

22. "name": "English             ",

23. "last_update": "2006-02-15T05:02:19"

24. }

25. },

26. {

27. "film_id": 2,

28. "title": "ACE GOLDFINGER",

29. "description": "A Astounding Epistle of a Database Administrator And a Explorer who must Find a Car in Ancient China",

30. "release_year": 2006,

31. "language_id": 1,

32. "original_language_id": null,

33. "rental_duration": 3,

34. "rental_rate": 4.99,

35. "length": 48,

36. "replacement_cost": 12.99,

37. "rating": "G",

38. "last_update": "2006-02-15T05:03:42",

39. "special_features": [

40. "Trailers",

41. "Deleted Scenes"

42. ],

43. "fulltext": "'ace':1 'administr':9 'ancient':19 'astound':4 'car':17 'china':20 'databas':8 'epistl':5 'explor':12 'find':15 'goldfing':2 'must':14",

44. "language": {

45. "language_id": 1,

46. "name": "English             ",

47. "last_update": "2006-02-15T05:02:19"

48. }

49. }

50. ]

Nous voyons dans le résultat que nous avons les données de la table « language », pour récupérer les attributs spécifiques de la table jointe, il faut les définir dans le nom de la table entre parenthèses, comme ici language(name)

1. http://localhost:3000/film?select=*,language(name)&limit=2

Cette requête dans PostgreSQL, donne ceci :

1. WITH pg_source AS (

2. SELECT "public"."film".*, row_to_json("language_language".*) AS "language"

3. FROM "public"."film"

4. LEFT JOIN LATERAL(

5. SELECT "public"."language"."name" FROM "public"."language"

6. WHERE "public"."language"."language_id" = "public"."film"."language_id"   ) AS "language_language" ON true

7. LIMIT 2 OFFSET 0

8. )

9. SELECT null AS total_result_set, pg_catalog.count(_postgrest_t) AS page_total,

10. array[]::text[] AS header,

11. coalesce(json_agg(_postgrest_t), '[]')::character varying AS body

12. FROM ( SELECT * FROM pg_source) _postgrest_t

Nous remarquons deux choses importantes, c'est que PostgREST utilise la fonction row_to_json(), pour faire l'embed de la table jointe, ce qui permet d'avoir également du Json.

La deuxième remarque est que la jointure est une jointure latérale de gauche, un LEFT JOIN LATERAL. Il faut en tenir compte, car pour le moment le INNER JOIN n'est pas possible.

Si on modifie quelque peu le contenu de la base de données :

1. update film set language_id = 2 where film_id = 2;

Afin d'avoir un film en italien et parce que je veux discriminer sur la table language, alors un left join retournera tout, même s'il ne trouve pas de données auquel cas, il restituera les attributs correspondants à « NULL ».

1. http://localhost:3000/film?select=*,language(name)&language.name=like.*Italian*

Donc ici, on fait une jointure dont l'attribut name de la table language est like '%Italian%'

Voici une partie du résultat :

1. {

2. "film_id": 1000,

3. "title": "ZORRO ARK",

4. "description": "A Intrepid Panorama of a Mad Scientist And a Boy who must Redeem a Boy in A Monastery",

5. "release_year": 2006,

6. "language_id": 1,

7. "original_language_id": null,

8. "rental_duration": 3,

9. "rental_rate": 4.99,

10. "length": 50,

11. "replacement_cost": 18.99,

12. "rating": "NC-17",

13. "last_update": "2006-02-15T05:03:42",

14. "special_features": [

15. "Trailers",

16. "Commentaries",

17. "Behind the Scenes"

18. ],

19. "fulltext": "'ark':2 'boy':12,17 'intrepid':4 'mad':8 'monasteri':20 'must':14 'panorama':5 'redeem':15 'scientist':9 'zorro':1",

20. "language": null

21. },

22. {

23. "film_id": 2,

24. "title": "ACE GOLDFINGER",

25. "description": "A Astounding Epistle of a Database Administrator And a Explorer who must Find a Car in Ancient China",

26. "release_year": 2006,

27. "language_id": 2,

28. "original_language_id": null,

29. "rental_duration": 3,

30. "rental_rate": 4.99,

31. "length": 48,

32. "replacement_cost": 12.99,

33. "rating": "G",

34. "last_update": "2019-12-11T14:26:49.203836",

35. "special_features": [

36. "Trailers",

37. "Deleted Scenes"

38. ],

39. "fulltext": "'ace':1 'administr':9 'ancient':19 'astound':4 'car':17 'china':20 'databas':8 'epistl':5 'explor':12 'find':15 'goldfing':2 'must':14",

40. "language": {

41. "name": "Italian             "

42. }

43. }

44. ]

On voit que le embed de language retourne des name null et les name Italian.

Il faudra alors penser à inverser la requête que l'on recherche à faire :

1. http://localhost:3000/language?select=name,film(*)&name=like.*Italian*

1. [

2. {

3. "name": "Italian             ",

4. "film": [

5. {

6. "film_id": 2,

7. "title": "ACE GOLDFINGER",

8. "description": "A Astounding Epistle of a Database Administrator And a Explorer who must Find a Car in Ancient China",

9. "release_year": 2006,

10. "language_id": 2,

11. "original_language_id": null,

12. "rental_duration": 3,

13. "rental_rate": 4.99,

14. "length": 48,

15. "replacement_cost": 12.99,

16. "rating": "G",

17. "last_update": "2019-12-11T14:29:53.488058",

18. "special_features": [

19. "Trailers",

20. "Deleted Scenes"

21. ],

22. "fulltext": "'ace':1 'administr':9 'ancient':19 'astound':4 'car':17 'china':20 'databas':8 'epistl':5 'explor':12 'find':15 'goldfing':2 'must':14"

23. }

24. ]

25. }

26. ]

Du coup, ici, c'est film qui est embed de language.

I-D-3 - Multi jointure de tables

Il est tout à fait possible de joindre plusieurs tables si le schéma le permet ; par exemple, film, language, film_actor et cela juste en ajoutant les tables à joindre :

1. http://localhost:3000/film?select=*,language(*),film_actor(*)&limit=2

1. [

2. {

3. "film_id": 1,

4. "title": "ACADEMY DINOSAUR",

5. "description": "A Epic Drama of a Feminist And a Mad Scientist who must Battle a Teacher in The Canadian Rockies",

6. "release_year": 2006,

7. "language_id": 1,

8. "original_language_id": null,

9. "rental_duration": 6,

10. "rental_rate": 0.99,

11. "length": 86,

12. "replacement_cost": 20.99,

13. "rating": "PG",

14. "last_update": "2006-02-15T05:03:42",

15. "special_features": [

16. "Deleted Scenes",

17. "Behind the Scenes"

18. ],

19. "fulltext": "'academi':1 'battl':15 'canadian':20 'dinosaur':2 'drama':5 'epic':4 'feminist':8 'mad':11 'must':14 'rocki':21 'scientist':12 'teacher':17",

20. "language": {

21. "language_id": 1,

22. "name": "English             ",

23. "last_update": "2006-02-15T05:02:19"

24. },

25. "film_actor": [

26. {

27. "actor_id": 1,

28. "film_id": 1,

29. "last_update": "2006-02-15T05:05:03"

30. },

31. {

32. "actor_id": 10,

33. "film_id": 1,

34. "last_update": "2006-02-15T05:05:03"

35. },

36. {

37. "actor_id": 20,

38. "film_id": 1,

39. "last_update": "2006-02-15T05:05:03"

40. },

41. {

42. "actor_id": 30,

43. "film_id": 1,

44. "last_update": "2006-02-15T05:05:03"

45. },

46. {

47. "actor_id": 40,

48. "film_id": 1,

49. "last_update": "2006-02-15T05:05:03"

50. },

51. {

52. "actor_id": 53,

53. "film_id": 1,

54. "last_update": "2006-02-15T05:05:03"

55. },

56. {

57. "actor_id": 108,

58. "film_id": 1,

59. "last_update": "2006-02-15T05:05:03"

60. },

61. {

62. "actor_id": 162,

63. "film_id": 1,

64. "last_update": "2006-02-15T05:05:03"

65. },

66. {

67. "actor_id": 188,

68. "film_id": 1,

69. "last_update": "2006-02-15T05:05:03"

70. },

71. {

72. "actor_id": 198,

73. "film_id": 1,

74. "last_update": "2006-02-15T05:05:03"

75. }

76. ]

77. },

78. {

79. "film_id": 3,

80. "title": "ADAPTATION HOLES",

81. "description": "A Astounding Reflection of a Lumberjack And a Car who must Sink a Lumberjack in A Baloon Factory",

82. "release_year": 2006,

83. "language_id": 1,

84. "original_language_id": null,

85. "rental_duration": 7,

86. "rental_rate": 2.99,

87. "length": 50,

88. "replacement_cost": 18.99,

89. "rating": "NC-17",

90. "last_update": "2006-02-15T05:03:42",

91. "special_features": [

92. "Trailers",

93. "Deleted Scenes"

94. ],

95. "fulltext": "'adapt':1 'astound':4 'baloon':19 'car':11 'factori':20 'hole':2 'lumberjack':8,16 'must':13 'reflect':5 'sink':14",

96. "language": {

97. "language_id": 1,

98. "name": "English             ",

99. "last_update": "2006-02-15T05:02:19"

100. },

101. "film_actor": [

102. {

103. "actor_id": 2,

104. "film_id": 3,

105. "last_update": "2006-02-15T05:05:03"

106. },

107. {

108. "actor_id": 19,

109. "film_id": 3,

110. "last_update": "2006-02-15T05:05:03"

111. },

112. {

113. "actor_id": 24,

114. "film_id": 3,

115. "last_update": "2006-02-15T05:05:03"

116. },

117. {

118. "actor_id": 64,

119. "film_id": 3,

120. "last_update": "2006-02-15T05:05:03"

121. },

122. {

123. "actor_id": 123,

124. "film_id": 3,

125. "last_update": "2006-02-15T05:05:03"

126. }

127. ]

128. }

129. ]

On voit ici que film_actor est joint dans le résultat.

Si on veut les acteurs des films, on appelle les tables concernées :

1. http://localhost:3000/film?select=*,film_actor(*),actor(*)&limit=1

1. [

2. {

3. "film_id": 1,

4. "title": "ACADEMY DINOSAUR",

5. "description": "A Epic Drama of a Feminist And a Mad Scientist who must Battle a Teacher in The Canadian Rockies",

6. "release_year": 2006,

7. "language_id": 1,

8. "original_language_id": null,

9. "rental_duration": 6,

10. "rental_rate": 0.99,

11. "length": 86,

12. "replacement_cost": 20.99,

13. "rating": "PG",

14. "last_update": "2006-02-15T05:03:42",

15. "special_features": [

16. "Deleted Scenes",

17. "Behind the Scenes"

18. ],

19. "fulltext": "'academi':1 'battl':15 'canadian':20 'dinosaur':2 'drama':5 'epic':4 'feminist':8 'mad':11 'must':14 'rocki':21 'scientist':12 'teacher':17",

20. "film_actor": [

21. {

22. "actor_id": 1,

23. "film_id": 1,

24. "last_update": "2006-02-15T05:05:03"

25. },

26. {

27. "actor_id": 10,

28. "film_id": 1,

29. "last_update": "2006-02-15T05:05:03"

30. },

31. {

32. "actor_id": 20,

33. "film_id": 1,

34. "last_update": "2006-02-15T05:05:03"

35. },

36. {

37. "actor_id": 30,

38. "film_id": 1,

39. "last_update": "2006-02-15T05:05:03"

40. },

41. {

42. "actor_id": 40,

43. "film_id": 1,

44. "last_update": "2006-02-15T05:05:03"

45. },

46. {

47. "actor_id": 53,

48. "film_id": 1,

49. "last_update": "2006-02-15T05:05:03"

50. },

51. {

52. "actor_id": 108,

53. "film_id": 1,

54. "last_update": "2006-02-15T05:05:03"

55. },

56. {

57. "actor_id": 162,

58. "film_id": 1,

59. "last_update": "2006-02-15T05:05:03"

60. },

61. {

62. "actor_id": 188,

63. "film_id": 1,

64. "last_update": "2006-02-15T05:05:03"

65. },

66. {

67. "actor_id": 198,

68. "film_id": 1,

69. "last_update": "2006-02-15T05:05:03"

70. }

71. ],

72. "actor": [

73. {

74. "actor_id": 1,

75. "first_name": "PENELOPE",

76. "last_name": "GUINESS",

77. "last_update": "2006-02-15T04:34:33"

78. },

79. {

80. "actor_id": 10,

81. "first_name": "CHRISTIAN",

82. "last_name": "GABLE",

83. "last_update": "2006-02-15T04:34:33"

84. },

85. {

86. "actor_id": 20,

87. "first_name": "LUCILLE",

88. "last_name": "TRACY",

89. "last_update": "2006-02-15T04:34:33"

90. },

91. {

92. "actor_id": 30,

93. "first_name": "SANDRA",

94. "last_name": "PECK",

95. "last_update": "2006-02-15T04:34:33"

96. },

97. {

98. "actor_id": 40,

99. "first_name": "JOHNNY",

100. "last_name": "CAGE",

101. "last_update": "2006-02-15T04:34:33"

102. },

103. {

104. "actor_id": 53,

105. "first_name": "MENA",

106. "last_name": "TEMPLE",

107. "last_update": "2006-02-15T04:34:33"

108. },

109. {

110. "actor_id": 108,

111. "first_name": "WARREN",

112. "last_name": "NOLTE",

113. "last_update": "2006-02-15T04:34:33"

114. },

115. {

116. "actor_id": 162,

117. "first_name": "OPRAH",

118. "last_name": "KILMER",

119. "last_update": "2006-02-15T04:34:33"

120. },

121. {

122. "actor_id": 188,

123. "first_name": "ROCK",

124. "last_name": "DUKAKIS",

125. "last_update": "2006-02-15T04:34:33"

126. },

127. {

128. "actor_id": 198,

129. "first_name": "MARY",

130. "last_name": "KEITEL",

131. "last_update": "2006-02-15T04:34:33"

132. }

133. ]

134. }

135. ]

Dans ce cas, nous devrons alors, grâce à un langage de programmation, refaire les jointures entre film_actor et actor.

Il est aussi possible de joindre la table actor à la jointure de la table film_actor :

1. http://localhost:3000/film?select=*,film_actor(*,actor(*))&limit=1

1. [

2. {

3. "film_id": 1,

4. "title": "ACADEMY DINOSAUR",

5. "description": "A Epic Drama of a Feminist And a Mad Scientist who must Battle a Teacher in The Canadian Rockies",

6. "release_year": 2006,

7. "language_id": 1,

8. "original_language_id": null,

9. "rental_duration": 6,

10. "rental_rate": 0.99,

11. "length": 86,

12. "replacement_cost": 20.99,

13. "rating": "PG",

14. "last_update": "2006-02-15T05:03:42",

15. "special_features": [

16. "Deleted Scenes",

17. "Behind the Scenes"

18. ],

19. "fulltext": "'academi':1 'battl':15 'canadian':20 'dinosaur':2 'drama':5 'epic':4 'feminist':8 'mad':11 'must':14 'rocki':21 'scientist':12 'teacher':17",

20. "film_actor": [

21. {

22. "actor_id": 1,

23. "film_id": 1,

24. "last_update": "2006-02-15T05:05:03",

25. "actor": {

26. "actor_id": 1,

27. "first_name": "PENELOPE",

28. "last_name": "GUINESS",

29. "last_update": "2006-02-15T04:34:33"

30. }

31. },

32. {

33. "actor_id": 10,

34. "film_id": 1,

35. "last_update": "2006-02-15T05:05:03",

36. "actor": {

37. "actor_id": 10,

38. "first_name": "CHRISTIAN",

39. "last_name": "GABLE",

40. "last_update": "2006-02-15T04:34:33"

41. }

42. },

43. {

44. "actor_id": 20,

45. "film_id": 1,

46. "last_update": "2006-02-15T05:05:03",

47. "actor": {

48. "actor_id": 20,

49. "first_name": "LUCILLE",

50. "last_name": "TRACY",

51. "last_update": "2006-02-15T04:34:33"

52. }

53. },

54. {

55. "actor_id": 30,

56. "film_id": 1,

57. "last_update": "2006-02-15T05:05:03",

58. "actor": {

59. "actor_id": 30,

60. "first_name": "SANDRA",

61. "last_name": "PECK",

62. "last_update": "2006-02-15T04:34:33"

63. }

64. },

65. {

66. "actor_id": 40,

67. "film_id": 1,

68. "last_update": "2006-02-15T05:05:03",

69. "actor": {

70. "actor_id": 40,

71. "first_name": "JOHNNY",

72. "last_name": "CAGE",

73. "last_update": "2006-02-15T04:34:33"

74. }

75. },

76. {

77. "actor_id": 53,

78. "film_id": 1,

79. "last_update": "2006-02-15T05:05:03",

80. "actor": {

81. "actor_id": 53,

82. "first_name": "MENA",

83. "last_name": "TEMPLE",

84. "last_update": "2006-02-15T04:34:33"

85. }

86. },

87. {

88. "actor_id": 108,

89. "film_id": 1,

90. "last_update": "2006-02-15T05:05:03",

91. "actor": {

92. "actor_id": 108,

93. "first_name": "WARREN",

94. "last_name": "NOLTE",

95. "last_update": "2006-02-15T04:34:33"

96. }

97. },

98. {

99. "actor_id": 162,

100. "film_id": 1,

101. "last_update": "2006-02-15T05:05:03",

102. "actor": {

103. "actor_id": 162,

104. "first_name": "OPRAH",

105. "last_name": "KILMER",

106. "last_update": "2006-02-15T04:34:33"

107. }

108. },

109. {

110. "actor_id": 188,

111. "film_id": 1,

112. "last_update": "2006-02-15T05:05:03",

113. "actor": {

114. "actor_id": 188,

115. "first_name": "ROCK",

116. "last_name": "DUKAKIS",

117. "last_update": "2006-02-15T04:34:33"

118. }

119. },

120. {

121. "actor_id": 198,

122. "film_id": 1,

123. "last_update": "2006-02-15T05:05:03",

124. "actor": {

125. "actor_id": 198,

126. "first_name": "MARY",

127. "last_name": "KEITEL",

128. "last_update": "2006-02-15T04:34:33"

129. }

130. }

131. ]

132. }

133. ]

On comprend aisément que l'outil est puissant et que tout n'est question que d'imbrications.

I-D-4 - Pagination

Il est tout à fait possible de retourner un jeu de résultats ordonné :

1. http://localhost:3000/film?order=language_id.desc

Ou de ne prendre qu'un offset pour paginer :

1. http://localhost:3000/film?order=language_id.desc&offset=30

Cette commande va prendre tout sauf les trente premiers résultats.

Une autre façon de faire est de spécifier dans les en-têtes l’intervalle (« range ») que nous voulons recevoir.

1. > GET /film?order=language_id.desc&offset=30 HTTP/1.1

2. > Host: localhost:3000

3. > User-Agent: insomnia/7.0.5

4. > Range: 0-50

5. > Accept: */*

Ici, nous aurons donc les 50 premiers résultats, pour les 50 suivants :

1. > GET /film?order=language_id.desc&offset=30 HTTP/1.1

2. > Host: localhost:3000

3. > User-Agent: insomnia/7.0.5

4. > Range: 51-100

5. > Accept: */*

Si, en plus, on veut le total de lignes possibles (count()), il faut aussi le spécifier dans l'en-tête avec la condition Prefer qui a pour valeur count=exact :

1. > GET /film?order=language_id.desc&offset=30 HTTP/1.1

2. > Host: localhost:3000

3. > User-Agent: insomnia/7.0.5

4. > Range: 51-100

5. > Prefer: count=exact

6. > Accept: */*

Qui aura comme retour dans les headers :

1. Transfer-Encoding: chunked

2. Date: Wed, 11 Dec 2019 14:38:50 GMT

3. Server: postgrest/6.0.2 (713b214)

4. Content-Type: application/json; charset=utf-8

5. Content-Range: 51-100/1000

6. Content-Location: /film?offset=30&order=language_id.desc

Avec cette information Content-Range: 51-100/1000, nous pourrons paginer.

I-E - Insertion

Une insertion est un post avec en paramètre un json reprenant les données à insérer.

Cela se fait au moyen d’un outil de type insomnia ou en langage de programmation.

On crée la route en POST et on passe un json :

1. {

2. "title": "Henallux",

3. "description": "G² fait un tuto pour ses collègues",

4. "release_year": 2006,

5. "language_id": 5,

6. "fulltext": "'abandon':20 'amus':21 'bang':1 'cat':11 'drama':5 'epic':4 'face':14 'kwai':2 'madman':8 'must':13 'park':22 'shark':17"

7. }

Si tout se passe bien, on récupère une réponse 201, avec en prime la route qui nous permet de vérifier :

1. > POST /film HTTP/1.1

2. > Host: localhost:3000

3. > User-Agent: insomnia/7.0.5

4. > Content-Type: application/json

5. > Accept: */*

6. > Content-Length: 278

8. {

9. "title": "Henallux",

10. "description": "G² fait un tuto pour ses collègues",

11. "release_year": 2006,

12. "language_id": 5,

13. "fulltext": "'abandon':20 'amus':21 'bang':1 'cat':11 'drama':5 'epic':4 'face':14 'kwai':2 'madman':8 'must':13 'park':22 'shark':17"

14. }

16. * upload completely sent off: 278 out of 278 bytes

17. * Mark bundle as not supporting multiuse

19. < HTTP/1.1 201 Created

20. < Transfer-Encoding: chunked

21. < Date: Wed, 11 Dec 2019 15:02:56 GMT

22. < Server: postgrest/6.0.2 (713b214)

23. < Location: /film?film_id=eq.1001

24. < Content-Range: */

I-F - Delete

Pour le delete, on crée une route avec le verbe delete et les paramètres de discrimination.

Pour supprimer une ligne dans la table film_actor :

1. http://localhost:3000/film_actor?actor_id=eq.1&film_id=eq.23

Le retour :

1. > DELETE /film_actor?actor_id=eq.1&film_id=eq.23 HTTP/1.1

2. > Host: localhost:3000

3. > User-Agent: insomnia/7.0.5

4. > Accept: */*

6. * Mark bundle as not supporting multiuse

8. < HTTP/1.1 204 No Content

9. < Date: Thu, 12 Dec 2019 08:29:54 GMT

10. < Server: postgrest/6.0.2 (713b214)

11. < Content-Range: */*

I-G - Update

Pour l'update c'est aussi facile, on discrimine une route et on envoie un json avec les attributs à modifier.

1. http://localhost:3000/film?film_id=eq.1001

1. {

2. "title": "Henallux the retour :) ",

3. "release_year": 2019

5. }

I-H - REST Classique et Https

Nous sommes plus souvent habitués à avoir des routes du genre :

1. http://localhost:3000/film/4

Pour récupérer l'ensemble des informations de la table film qui a pour id 4, ce n'est pas la solution prise par PostgREST, qui veut être proche d'une nomenclature du genre de GraphQL.

Néanmoins, cela peut se mettre en place facilement avec un proxy de type Nginx

1. # support /endpoint/:id url style

2. location ~ ^/([a-z_]+)/([0-9]+) {

4. # make the response singular

5. proxy_set_header Accept 'application/vnd.pgrst.object+json';

7. proxy_pass http://localhost:3000/fiml?film_id=eq.$1;

9. }

De même, je vous renvoie sur la doc de votre proxy pour gérer la sécurisation (https) de vos requêtes.

II - Swagger

PostgREST est conforme à la spécification OpenAPI , c'est d'ailleurs cette spécification qui est envoyée en appelant l'API à sa racine.

Il est donc possible d'autodocumenter ses routes avec une image docker de Swagger.

Dans le fichier docker-compose, on ajoute les lignes suivantes :

1. # docker-compose.yml

3. version: '3'

4. services:

5. server:

6. image: postgrest/postgrest

7. ports:

8. - "3000:3000"

9. environment:

10. PGRST_DB_URI: postgres://authenticator:mysecretpassword@localhost:5432/film

11. PGRST_DB_SCHEMA: public

12. PGRST_DB_ANON_ROLE: anonymous

13. network_mode: host

15. swagger:

16. image: swaggerapi/swagger-ui

17. ports:

18. - "8181:8080"

19. expose:

20. - "8181"

21. environment:

22. API_URL: http://localhost:3000/

Et sur le port 8181 en localhost, on obtient une documentation de nos routes.

III - Authentification JWT

Il existe plusieurs façons de sécuriser son API, mon choix c'est porté sur le Json Web Token qui est un standard lié à la RFC 7519, grâce au site jwt.io, on peut voir qu'il existe une extension pour PostgreSQL qui est facile à mettre en place.

Je vais décrire ici le processus que j'ai mis en place pour sécuriser mon API.

Mon moteur de base de données PostgreSQL tourne sur une Ubuntu Server

La procédure n'est pas compliquée, mais un peu longue.

III-A - Principe de base

Ce que nous allons mettre en place, c'est un système d'utilisateurs qui se substitueront à un rôle.

Un rôle avec des droits spécifiques sera créé dans PostgreSQL. Dans une table, nous créerons des utilisateurs qui prendront le statut du rôle créé et pourront lancer des requêtes.

De nouveau, nous déléguons à PostgreSQL le soin de gérer ses droits (grant), cela va permettre de créer des rôles avec une granularité limitée par les possibilités de PostgreSQL, autant dire peu de contraintes.

III-A-1 - Installation extension jwt PostgreSQL

On commence par installer les outils de développement PostgreSQL. Dans mon cas, c’est en version 11.

1. sudo apt-get install postgresql-server-dev-11

Ensuite, on clone le projet pgjwt (n'oubliez pas de le forker, on ne sait jamais). Et on rentre dans le répertoire :

1. git clone https://github.com/michelp/pgjwt.git && cd pgjwt

On installe l'extension dans PostgreSQL :

1. sudo make install

Normalement la sortie donne quelque chose comme :

1. /bin/mkdir -p '/usr/share/postgresql/11/extension'

2. /bin/mkdir -p '/usr/share/postgresql/11/extension'

3. /usr/bin/install -c -m 644 .//pgjwt.control '/usr/share/postgresql/11/extension/'

4. /usr/bin/install -c -m 644 .//pgjwt--0.1.0.sql  '/usr/share/postgresql/11/extension/'

Voilà pour la partie serveur ; c'est fini.

III-A-2 - Activation des extensions dans PostgreSQL

Nous avons besoin de deux extensions pgcrypto (pour crypter) et pgjwt que nous venons de compiler.

1. create extension pgcrypto;

2. create extension pgjwt;

III-A-3 - Mise en place des processus JWT

Jwt étant basé sur une clef secrète, on va la stocker dans notre DB (32 caractères, c'est bien !)

1. ALTER DATABASE film SET "public.jwt_secret" TO 'mysuperkeysecretmysuperkeysecret';

Création d'un schéma pour la gestion de l'authentification :

1. create schema if not exists basic_auth;

Création de la table qui va gérer nos utilisateurs (différents des rôles, donc) :

1. create table if not exists

2. basic_auth.users (

3. pseudo   text primary key check ( length(pseudo) < 50),

4. pass     text not null check (length(pass) < 512),

5. role     name not null check (length(role) < 512)

6. );

Il faut créer maintenant une série de fonctions et procédures qui vont nous permettre de tout faire fonctionner.

Création de la fonction qui va vérifier que le rôle existe :

1. create or replace function

2. basic_auth.check_role_exists() returns trigger as $$

3. begin

4. if not exists (select 1 from pg_roles as r where r.rolname = new.role) then

5. raise foreign_key_violation using message =

6. 'unknown database role: ' || new.role;

7. return null;

8. end if;

9. return new;

10. end

11. $$ language plpgsql;

Création de la procédure qui, après un insert ou update de la table users, va lancer la fonction basic_auth.check_role_exists() :

1. drop trigger if exists ensure_user_role_exists on basic_auth.users;

2. create constraint trigger ensure_user_role_exists

3. after insert or update on basic_auth.users

4. for each row

5. execute procedure basic_auth.check_role_exists();

Création de la fonction qui va crypter notre mot de passe en bf, md5, xdes, des. Je vous renvoie à la doc de pgcrypto pour plus de renseignements : https://www.postgresql.org/docs/11/pgcrypto.html

1. create or replace function

2. basic_auth.encrypt_pass() returns trigger as $$

3. begin

4. if tg_op = 'INSERT' or new.pass <> old.pass then

5. new.pass = crypt(new.pass, gen_salt('bf'));

6. end if;

7. return new;

8. end

9. $$ language plpgsql;

10. -- triger sur insert ou update

11. drop trigger if exists encrypt_pass on basic_auth.users;

12. create trigger encrypt_pass

13. before insert or update on basic_auth.users

14. for each row

15. execute procedure basic_auth.encrypt_pass();

Création de la fonction qui va substituer le rôle anonymous de base, à celui défini par la table users

1. create or replace function

2. basic_auth.user_role(pseudo text, pass text) returns name

3. language plpgsql

4. as $$

5. begin

6. return (

7. select role from basic_auth.users

8. where users.pseudo = user_role.pseudo

9. and users.pass = crypt(user_role.pass, users.pass)

10. );

11. end;

12. $$;

Création d’un type token :

1. CREATE TYPE basic_auth.jwt_token AS (

2. token text

3. );

Création de la fonction login, à mettre dans votre schéma courant (ici public) :

1. CREATE OR REPLACE FUNCTION public.login(

2. pseudo text,

3. pass text)

4. RETURNS basic_auth.jwt_token

5. LANGUAGE 'plpgsql'

7. COST 100

8. VOLATILE SECURITY DEFINER

9. AS $BODY$

10. declare

11. _role name;

12. result basic_auth.jwt_token;

13. begin

14. -- check email and password

15. select basic_auth.user_role(pseudo, pass) into _role;

16. if _role is null then

17. raise invalid_password using message = 'invalid user or password';

18. end if;

20. select sign(

21. row_to_json(r), current_setting('public.jwt_secret')

22. ) as token

23. from (

24. select _role as role, login.pseudo as pseudo,

25. extract(epoch from now())::integer + 60*60 as exp

26. ) r

27. into result;

28. return result;

29. end;

30. $BODY$;

Attribution des droits qui vont bien :

1. ALTER FUNCTION brain.login(text, text)

2. OWNER TO postgres;

4. GRANT EXECUTE ON FUNCTION brain.login(text, text) TO postgres;

6. GRANT EXECUTE ON FUNCTION brain.login(text, text) TO PUBLIC;

8. GRANT EXECUTE ON FUNCTION brain.login(text, text) TO anonymous;

Si vous avez suivi l'article depuis le début, vous comprendrez qu’il faut enlever des droits au rôle anonymous pour qu'il ne puisse que faire usage du schéma public, rien d'autre :

1. REVOKE ALL ON table language,category,actor_info,film_category,actor,film_actor,film FROM anonymous;

2. GRANT anonymous to authenticator;

3. GRANT USAGE ON SCHEMA public TO anonymous;

Je vous renvoie au début de l'article pour la gestion de authenticator et anonymous.

Création d’un rôle qui pourra avoir les droits select sur les tables film, film_actor et actor

1. CREATE ROLE "readall" WITH

2. NOLOGIN

3. NOSUPERUSER

4. NOCREATEDB

5. NOCREATEROLE

6. INHERIT

7. NOREPLICATION

8. CONNECTION LIMIT -1;

10. -- on donne la possibilité à anonymous de changer de rôle

11. GRANT readall TO anonymous;

12. -- on donne le droit usage au schéma public

13. GRANT USAGE ON SCHEMA public TO readall;

14. -- on donne les droits aux tables

15. GRANT SELECT ON TABLE public.actor TO "readall";

16. GRANT SELECT ON TABLE public.film TO "readall";

17. GRANT SELECT ON TABLE public.film_actor TO "readall";

Création d’un user qui va créer un token et prendre le rôle readall:

1. INSERT INTO basic_auth.users (pseudo,pass,role) VALUES ('jhon','bonjour','readall');

Qui avec les fonctions de pgcrypto donnera ceci :

1. "pseudo","pass","role"

2. "jhon","$2a$06$i5OZQuo1A0Vg4QOf1Y4sZeARndLOWLtF6v0UFCZfwFy30xW3XSdXC","readall"

À partir de maintenant, si on ne possède pas de token, nous n'avons plus accès à nos données :

1. {

2. "hint": null,

3. "details": null,

4. "code": "42501",

5. "message": "permission denied for table film"

6. }

III-A-4 - Login

Nous devons maintenant nous connecter pour disposer d'un token.

Les routes, permettant d'avoir accès aux fonctions, doivent être précédées de rpc.

Donc pour se connecter, avec une route en POST :

1. http://localhost:3000/rpc/login

Et le json qui va bien :

1. {

2. "pseudo":"jhon",

3. "pass":"bonjour"

4. }

On va donc prendre le rôle de readall et cela va nous retourner un token de type bearer :

1. [

2. {

3. "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoicmVhZGFsbCIsInBzZXVkbyI6Impob24iLCJleHAiOjE1NzYxNjEwNzZ9.cV6gdduj0xpaT3fg4zqtswNDdxGZpr-06kq2aDqnk8A"

4. }

5. ]

Nous aurons besoin maintenant d'une Authorisation de type Bearer pour faire nos requêtes et être ainsi sécurisés.

Donc, pour une requête sur la table film, un get avec le token :

1. > GET /film HTTP/1.1

2. > Host: localhost:3000

3. > User-Agent: insomnia/7.0.5

4. > Prefer: count=exact

5. > Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoicmVhZGFsbCIsInBzZXVkbyI6Impob24iLCJleHAiOjE1NzYxNjEwNzZ9.cV6gdduj0xpaT3fg4zqtswNDdxGZpr-06kq2aDqnk8A

6. > Accept: */*

IV - Http-Client Symfony

Je travaille essentiellement en PHP, voici donc comment, dans mon langage de prédilection, je fais pour une requête GET :

J'installe d'abord le http-client dans mon projet Symfony, Laravel, Yii, ou autre…

1. composer require symfony/http-client

J’exécute ensuite le code suivant :

1. // j'instancie le client

2. $client = HttpClient::create();

3. // je récupère le token

4. $token = $client->request('POST', 'http://localhost:3000/rpc/login', [

5. 'body' => ["pseudo" => "jhon", "pass" => "bonjour"]

6. ]);

8. // je crée un ensemble d'options, avec le token

9. $options = [

10. 'headers' => [

11. 'Prefer' => 'count=exact',

12. 'Authorization' => 'Bearer ' . $token->toArray()[0]['token']]

13. ];

14. // j'appelle mon API, avec le token en options

15. $response = $client->request('GET', 'http://localhost:3000/film', $options);

16. // j'affiche le résultat sous forme de tableau

17. dd($response->toArray());

Résultat

V - Conclusion

PostgREST offre une API qui utilise toute la puissance de PostgreSQL et cela de façon presque naturelle.

Si les routes se complexifient, il faut alors se retourner vers les vues, qui étendront aisément toutes nos requêtes.

Le projet est en développement actif et les membres sont assez réactifs à nos demandes.

Ce projet remplacera facilement tout CRUD inutile à développer, en plus d'offrir à vos utilisateurs la possibilité de recevoir des données non limitées par des routes, qui contraignent la sortie.

VI - Remerciments

Que soient remerciés ici tous ceux qui m'ont apporté une aide précieuse à la confection de cet article, je pense à Grazouilli et Escartefigue (pour les fôtes) ainsi que Claude Leloup (pour le XML).