Modules JavaScript natifs et isomorphisme avec import, export et require

Bruno Lesieur

Si vous êtes développeur web, vous devez savoir que pour que l'utilisateur final puisse afficher une page web sur son navigateur via le protocole HTTP, il faut deux choses : un code client, et un code serveur :

- Dans son plus simple appareil, le code serveur est délivré par un serveur web comme Apache, nginx ou IIS à partir d'un fichier. Dans de nombreux cas, ce n'est pas à partir d'un fichier HTML, mais à partir du résultat créé en analysant du code serveur dans des fichiers PHP, .NET, Python, Ruby, etc. qu'est généré le rendu HTML.

- Côté client, une fois la page reçue, le HTML sert de base au navigateur pour construire un DOM qui permettra d'afficher le site web. C'est alors le code JavaScript appelé par la page qui permettra de changer le DOM et donc, de faire des interactions à l'écran.

Le développeur a donc deux travaux, développer un code qui fonctionne côté serveur et développer un autre code qui fonctionne côté client (le serveur web étant la passerelle entre client et serveur), d'où la séparation connue des rôles de développeur front-end (partie cliente) et développeur back-end (partie serveur).

Imaginez que l'on puisse, à partir d'exactement le même code, produire du code côté serveur et côté client ! C'est ce que l'on appelle l'isomorphisme. Un code isomorphique est un code qui peut-être exécuté par le serveur et par le client.

Nous allons donc utiliser le sujet de l'isomorphisme comme fil conducteur dans cet article pour traiter :

- de l'import / export de Modules ECMAScript en version 6 ;

- du JavaScript côté serveur avec Node.js ;

- des équivalences ECMAScript version 5 pour le require / export ;

- de l'isomorphisme exploitable pour faire du web avec Vanilla JS et Node.js.

Commentez

- Titre : Modules JavaScript natifs et isomorphisme avec import, export et require

- Auteur : Bruno Lesieur

- Parution : 19 avril 2018

- Licence : Copyright ® 2018 Bruno Lesieur. 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. Exécution côté client avec les Modules ECMAScript

- I-A. Architecture

- I-B. Quelques erreurs

- I-C. Résultat

- II. Exécution côté serveur des Modules ECMAScript avec Node.js

- II-A. Fonctionnalité expérimentale

- II-B. Résultat

- II-C. Et le client ?

- III. Méthodes ES5 pour l'import / export

- III-A. Côté serveur

- III-B. Côté client

- IV. Isomorphisme exploitable pour un site web avec Vanilla JS et Node.js

- IV-A. Partie cliente, partie serveur et partie isomorphique

- IV-B. Le serveur HTTP

- IV-C. Les fichiers isomporphiques

- IV-D. Le navigateur web

- V. Conclusion

- VI. Remerciements

I - Exécution côté client avec les Modules ECMAScript

Pour commencer, utilisons un navigateur récent (Chrome, Firefox, Edge, Safari…) et faisons des choses très simples. En ECMAScript version 6 (« ES6 ») — qui succède la très populaire ECMAScript version 5 (« ES5 ») progressivement dans tous les navigateurs — il existe une manière de packager et servir du code JavaScript sous forme d'unités de code. Ces unités de code se suffisent à elles-mêmes et peuvent être réutilisées par d'autres unités de code. C'est ce qu'on appelle les Modules ECMAScript. Voici les étapes de mise en place :

- je crée un module JavaScript grâce au nouveau mot clé réservé du langage export ;

- et j'utilise un module JavaScript grâce au nouveau mot clé réservé du langage import.

I-A - Architecture

Testons donc cela dans un navigateur à travers l'architecture de fichier suivante :

1. isomorphism/

2. ├─ javascripts/

3. │  ├─ operation.js

4. │  └─ isomorphic.js

5. └─ es6.htm

Nous allons donc remplir le fichier es6.htm avec le contenu suivant :

es6.htm (code source)

1. <!DOCTYPE html>

2. <html lang="en">

3. <head>

4. <meta charset="utf-8" />

5. <title>ES6 example</title>

6. </head>

7. <body>

8. <section class="main-content">

9. <h1>Instructions:</h1>

10. <p>Open console with F12.</p>

11. </section>

12. <!-- Appel des différents fichiers

13. à faire exécuter par le

14. moteur JavaScript du navigateur. -->

15. <script src="javascripts/operation.js"></script>

16. <script src="javascripts/isomorphic.js"></script>

17. </body>

18. </html>

Nous allons ensuite nous créer un module JavaScript dans le fichier operation.js :

javascripts/operation.js (code source)

1. /* Export direct. */

2. export default function (number) {

3. return {

4. round: Math.round(number),

5. floor: Math.floor(number),

6. ceil: Math.ceil(number)

7. };

8. }

9. /* Export nommé `addition`. */

10. export function addition(number1, number2) {

11. return number1 + number2;

12. }

13. /* Export nommé `substraction`. */

14. export function substraction(number1, number2) {

15. return number1 - number2;

16. }

17. /* Export nommé `multiplication`. */

18. export function multiplication(number1, number2) {

19. return number1 * number2;

20. }

21. /* Export nommé `division`. */

22. export function division(number1, number2) {

23. return number1 / number2;

24. }

Et nous allons créer le cœur du programme dans un module isomorphic.js qui fera office de contrôleur :

javascripts/isomorphic.js (code source)

1. /* Récupération du module direct depuis `export default function ()` */

2. import tools from "./operation.js";

3. /* Récupération des exports nommés du module avec `export function <name>()` */

4. import { addition, substraction, multiplication, division } from "./operation.js";

5. /* Variables à tester. */

6. var number1 = 13,

7. number2 = 7.7;

8. /* Utilisation des fonctions de nos modules. */

9. console.log('addition', addition(number1, number2));

10. console.log('substraction', substraction(number1, number2));

11. console.log('multiplication', multiplication(number1, number2));

12. console.log('division', division(number1, number2));

13. console.log('round', tools(number2).round);

14. console.log('floor', tools(number2).floor);

15. console.log('ceil', tools(number2).ceil);

I-B - Quelques erreurs

Nous allons donc ouvrir le fichier es6.htm dans le navigateur et ouvrir notre console avec F12.

Les erreurs suivantes sont affichées (dans Chrome) :

Access to Script at 'file:///<path/to/your/workspace>/isomorphism/javascripts/operation.js' from origin 'null' has been blocked by CORS policy: Invalid response. Origin 'null' is therefore not allowed access.
Access to Script at 'file:///<path/to/your/workspace>/isomorphism/javascripts/isomporphic.js' from origin 'null' has been blocked by CORS policy: Invalid response. Origin 'null' is therefore not allowed access.

Cela est dû au fait qu'il vous faut l'autorisation d'utiliser un module depuis un autre nom de domaine que le vôtre à cause du mécanisme de « Cross-origin resource sharing » des navigateurs. Vous allez me dire que vos fichiers .js sont pourtant sur le même serveur web que votre page .htm ? En fait, pour que ce soit le cas, il faudrait que votre page soit sur un serveur web ! Aussi dans l'URL de votre page dans le navigateur, il faudrait que file:///<path/to/your/workspace>/es6.htm soit remplacée, par exemple par http://<your-local-domain-name>/es6.htm. Lançons donc un serveur web.

De mon côté, je vais utiliser Node.js qui une fois installé me donne accès à la commande npm install -g node-atlas, ce qui me permet d'utiliser la commande node-atlas. Celle-ci lance un serveur web basique là où elle est lancée. Vous pouvez tout autant utiliser http-server ou votre propre serveur Apache, etc. pour tester ça.

Une fois le serveur web lancé, en vous rendant à http://<your-local-domain-name>/es6.htm, vous aurez cette fois l'erreur suivante :

Uncaught SyntaxError: Unexpected token export
Uncaught SyntaxError: Unexpected token import

Cela vient du fait que pour utiliser des modules JavaScript, il faut le préciser dans le type de la balise <script>. Notre code HTML précédent devient donc :

es6.htm (code source)

1. ...

2. <script src="javascripts/operation.js" type="module"></script>

3. <script src="javascripts/isomorphic.js" type="module"></script>

4. ...

I-C - Résultat

Cette fois la magie opère ! Vous constaterez dans votre console les sorties suivantes :

1. addition 20.7

2. substraction 5.3

3. multiplication 100.10000000000001

4. division 1.6883116883116882

5. round 8

6. floor 7

7. ceil 8

Vous pouvez aussi voir ce résultat en live en vous rendant à cette adresse qui se sert d'un serveur web GitHub Pages pour faire fonctionner l'exemple ES6.

II - Exécution côté serveur des Modules ECMAScript avec Node.js

L'idée ici va être de faire exécuter le fichier isomorphic.js du côté serveur. Il va faire appel à operation.js afin d'obtenir le même résultat que côté client dans votre console. Pour cela nous allons utiliser la commande :

> node ./javascripts/isomorphic.js

depuis le dossier où se situe actuellement es6.htm.

Mais faire cela nous renvoie l'erreur :

SyntaxError: Unexpected token import
...

II-A - Fonctionnalité expérimentale

Pour pouvoir exécuter notre fichier isomorphic.js côté serveur, il va falloir utiliser une fonctionnalité expérimentale de Node.js car, à l'heure actuelle, les Modules ECMAScript (« ESM ») ne sont pas supportés par Node.js en standard. En réalité, Node.js a déjà son propre système de chargement de module basé sur une spécification appelée CommonJS. Parce que Node.js a déjà son système d'import, appelé require, le meilleur moyen pour lui de savoir si un fichier doit être interprété en tant que Module ECMAScript ou en tant que module Node.js standard est de vérifier l'extension du fichier. C'est pourquoi un fichier JavaScript écrit sous forme de module ne doit plus avoir l'extension .js mais l'extension .mjs. Dans ce cas, Node.js sait que c'est un Module ECMAScript et utilise le système de chargement de module ESM et non CommonJS.

Nous allons donc dans un premier temps renommer nos fichiers operation.js et isomorphic.js en operation.mjs et isomorphic.mjs :

1. isomorphism/

2. ├─ javascripts/

3. │  ├─ operation.mjs

4. │  └─ isomorphic.mjs

5. └─ es6.htm

Et puisque le nom a changé, notre fichier isomorphic.mjs va maintenant faire appel à operation.mjs.

javascripts/isomorphic.mjs (code source)

1. /* Récupération du module direct depuis `export default function ()` */

2. import tools from "./operation.mjs";

3. /* Récupération des exports nommés du module avec `export function <name>()` */

4. import { addition, substraction, multiplication, division } from "./operation.mjs";

5. ...

II-B - Résultat

Il est à présent possible d'obtenir le même résultat que côté client avec la commande :

> node --experimental-modules ./javascripts/isomorphic.mjs

Vous obtiendrez alors la sortie :

1. addition 20.7

2. substraction 5.3

3. multiplication 100.10000000000001

4. division 1.6883116883116882

5. round 8

6. floor 7

7. ceil 8

II-C - Et le client ?

Pour finir, afin de toujours rendre opérationnel notre appel depuis http://<your-local-domain-name>/es6.htm, nous allons également changer les chemins vers les nouveaux fichiers operation.mjs et isomorphic.mjs :

1. ...

2. <script src="javascripts/operation.mjs" type="module"></script>

3. <script src="javascripts/isomorphic.mjs" type="module"></script>

4. ...

Nous avons ici un exemple de fichiers ES6 parfaitement isomorphiques !

Vous pouvez revoir ce résultat en live en vous rendant sur le serveur web GitHub Pages.

III - Méthodes ES5 pour l'import / export

Comme vous avez pu le constater, la fonctionnalité de Modules ECMAScript est expérimentale côté serveur et pas encore totalement supportée par tous les navigateurs côté client, car elle est introduite avec ES6. La question que l'on peut se poser est la suivante : est-il nécessaire d'utiliser une syntaxe ES6 et un Module ECMAScript pour faire de l'isomorphisme ? La réponse est non. Il est tout à fait possible d'arriver au même résultat en utilisant les modules CommonJS utilisés par Node.js et en mimant ce mécanisme côté client.

Nous allons ajouter les fichiers operation.js et isomorphic.js qui n'utilisent pas la syntaxe de module ES6, et créer un nouveau fichier es5.htm qui utilisera ces fichiers.

1. isomorphism/

2. ├─ javascripts/

3. │  ├─ operation.js

4. │  ├─ operation.mjs

5. │  ├─ isomorphic.js

6. │  └─ isomorphic.mjs

7. ├─ es5.htm

8. └─ es6.htm

III-A - Côté serveur

Nous allons par ailleurs dans chacun de ces fichiers utiliser l'export CommonJS de Node.js. Celui-ci fonctionne avec les propriétés module.exports et require.

Nous permettons donc l'export de nos fonctionnalités :

javascripts/operation.js (code source)

1. /* Export CommonJS de Node.js. */

2. module.exports = function (number) {

3. return {

4. /* Export direct. */

5. round: Math.round(number),

6. floor: Math.floor(number),

7. ceil: Math.ceil(number),

8. /* Export fonction `addition`. */

9. addition: function (number1, number2) {

10. return number1 + number2;

11. },

12. /* Export fonction `substraction`. */

13. substraction: function (number1, number2) {

14. return number1 - number2;

15. },

16. /* Export fonction `multiplication`. */

17. multiplication: function (number1, number2) {

18. return number1 * number2;

19. },

20. /* Export fonction `division`. */

21. division: function (number1, number2) {

22. return number1 / number2;

23. }

24. };

25. };

Puis nous les exécutons depuis le script d'appel :

javascripts/isomorphic.js (code source)

1. /* Variables à tester. */

2. var number1 = 13,

3. number2 = 7.7,

4. /* Récupération du module direct depuis `module.exports` */

5. tools = require('./operation.js'),

6. operation = tools();

7. /* Utilisation des fonctions de notre import. */

8. console.log('addition', operation.addition(number1, number2));

9. console.log('substraction', operation.substraction(number1, number2));

10. console.log('multiplication', operation.multiplication(number1, number2));

11. console.log('division', operation.division(number1, number2));

12. console.log('round', tools(number2).round);

13. console.log('floor', tools(number2).floor);

14. console.log('ceil', tools(number2).ceil);

Nous obtenons alors avec la commande :

> node ./javascripts/isomorphic.js

le résultat suivant :

1. addition 20.7

2. substraction 5.3

3. multiplication 100.10000000000001

4. division 1.6883116883116882

5. round 8

6. floor 7

7. ceil 8

III-B - Côté client

Alimentons alors côté client notre fichier es5.htm :

es5.htm (code source)

1. <!DOCTYPE html>

2. <html lang="en">

3. <head>

4. <meta charset="utf-8" />

5. <title>ES5 example</title>

6. </head>

7. <body>

8. <section class="main-content">

9. <h1>Instructions:</h1>

10. <p>Open console with F12.</p>

11. </section>

12. <script>var module = {};</script>

13. <script src="javascripts/operation.js"></script>

14. <script>var require = function () { return module.exports; }</script>

15. <script src="javascripts/isomorphic.js"></script>

16. </body>

17. </html>

Ce qui nous permet d'obtenir à l'adresse http://<your-local-domain-name>/es5.htm, en allant dans la console derrière F12 le résultat :

1. addition 20.7

2. substraction 5.3

3. multiplication 100.10000000000001

4. division 1.6883116883116882

5. round 8

6. floor 7

7. ceil 8

Nous avons alors « presque » à faire à de l'isomorphisme, car nous avons dû ajouter les morceaux de code :

<script>var module = {};</script>

et :

<script>var require = function () { return module.exports; }</script>

pour simuler le comportement de CommonJS côté client.

Vous pouvez aussi voir ce résultat en live en vous rendant à cette adresse qui se sert d'un serveur web GitHub Pages pour faire fonctionner l'exemple ES5.

IV - Isomorphisme exploitable pour un site web avec Vanilla JS et Node.js

Vous aurez probablement remarqué que les trois premières parties de cet article vous font une belle jambe pour faire un site web. Certes, le résultat est exécuté de la même manière avec une commande node (côté serveur) qu'avec un appel depuis une balise <script> mais vous ne pouvez rien en faire. Effectivement, la grande différence entre client et serveur c'est que ce que vous ferez côté client consistera à manipuler le DOM alors que ce que vous ferez côté serveur consistera à générer une réponse HTTP à envoyer au client. On est donc loin des messages à afficher dans la console !

IV-A - Partie cliente, partie serveur et partie isomorphique

Nous pouvons donc voir assez rapidement que la totalité du code ne pourra pas être isomorphique. Il y aura forcément :

- coté serveur, du code dédié à faire le pont entre les fichiers et données stockées sur le serveur et leurs envois par réponse HTTP. Ce sera le code uniquement serveur ;

- côté client, du code dédié à faire le pont entre ce que l'on récupère en source HTML ou par requête XMLHttpRequest et le DOM. Ce sera le code uniquement client.

Cependant, hormis ces mécanismes, la totalité du code restant pourra être utilisée aussi bien pour générer côté serveur la réponse HTTP dont va se servir le client pour générer son DOM lors du premier affichage, que pour hydrater le code côté client ou générer toutes les nouvelles pages visitées sans solliciter le serveur.

C'est à cette condition que nous pourrons réellement estimer que l'on développe une application isomorphique.

Voyons cela par l'exemple côté navigateur sans bibliothèque avec Vanilla JS et côté serveur avec Node.js !

IV-B - Le serveur HTTP

Nous allons donc créer un serveur Node.js dans le fichier server.js en utilisant l'API HTTP native de Node.js ainsi que le module communautaire JSDOM permettant de manipuler virtuellement le DOM côté serveur afin d'exploiter du code isomorphique. Nous aurions pu utiliser Express ou NodeAtlas pour faire cela avec facilité, mais ce sera un bon exercice de compréhension complète de A à Z sans zones d'ombres.

Partons de la structure actuelle à laquelle nous allons rajouter notre fichier server.js pour développer le code serveur non isomorphique servant les fichiers demandés au client ainsi que le fichier package.json pour permettre l'installation du DOM virtuel JSDOM. Nous allons également créer un fichier layout.htm qui va servir de base HTML pour tous les fichiers renvoyés par le serveur.

1. isomorphism/

2. ├─ javascripts/

3. │  ├─ isomorphic.js

4. │  ├─ isomorphic.mjs

5. │  ├─ operation.js

6. │  ├─ operation.mjs

7. ├─ es5.htm

8. ├─ es6.htm

9. ├─ layout.htm

10. ├─ server.js

11. └─ package.json

Remplissons le fichier package.json avec :

package.json (code source)

{}

Puis exécutons la commande :

> npm install --save jsdom

Ce qui va remplir le fichier package.json ainsi :

package.json (code source)

1. {

2. "dependencies": {

3. "jsdom": "^11.5.1"

4. }

5. }

et créer un fichier package-lock.json.

Grâce à cela, le module communautaire npm JSDOM et ses dépendances seront installés dans le dossier node_modules.

Basiquement, notre fichier layout.htm ressemblera à cela :

layout.htm (code source)

1. <!DOCTYPE html>

2. <html lang="en">

3. <head>

4. <base href="MyBase" />

5. <meta charset="utf-8" />

6. <title>Isomporphic example</title>

7. <!-- Un peu de CSS pour faire changer les

8. pages en changeant l'opacité. -->

9. <style>

10. /* Chaque `div` `layout` va s'afficher

11. les unes sur les autres permettant

12. de faire disparaitre progressivement

13. celle du dessus… */

14. .layout {

15. position: absolute;

16. width: 100%;

17. height: 100%;

18. top: 0;

19. left: 0;

20. opacity: 1;

21. background-color: #fff;

22. -webkit-transition: opacity 1s ease;

23. -moz-transition: opacity 1s ease;

24. -ms-transition: opacity 1s ease;

25. -o-transition: opacity 1s ease;

26. transition: opacity 1s ease;

27. }

28. /* … pour rendre visible celle

29. du dessous. Nous verrons cela

30. plus loin. */

31. .change {

32. opacity: 0;

33. z-index: 2;

34. }

35. </style>

36. </head>

37. <body>

38. <!-- Ici sera montée la page demandée par le routeur

39. côté serveur ou sera hydratée la page demandée

40. côté client. -->

41. <div class="layout"></div>

42. <!-- Ici sera exécuté la partie cliente -->

43. <script src="javascripts/client.js"></script>

44. </body>

45. </html>

Remplissons maintenant le fichier server.js avec le code serveur dédié :

server.js (code source)

1. /* Récupération de l'API native HTTP

2. * pour faire des échanges client-server

3. * (l'équivalent de APACHE). */

4. var http = require('http'),

5. /* Récupération de l'API native File System

6. * pour lire et écrire dans des fichiers

7. * sur le serveur. */

8. fs = require('fs'),

9. /* Récupération de la bibliothèque JSDOM

10. * pour lire et écrire dans des fichiers

11. * sur le serveur. */

12. JSDOM = require('jsdom').JSDOM,

13. /* Port d'écoute de notre site web. */

14. httpPort = 8080,

15. /* Nom de domaine de notre site web. */

16. httpDomain = 'localhost';

17. /* Création du serveur web avec

18. * récupération de toutes les requêtes faites

19. * par le navigateur dans `request` et un objet

20. * `response` pour renvoyer le contenu HTML demandé

21. * au navigateur. */

22. http.createServer(function (request, response) {

23. var router,

24. file,

25. statusCode,

26. contentType;

27. /* Cas des demandes d'adresse finissant par `/`. */

28. if (/\/$/g.test(request.url)) {

29. /* Le site répondra donc à :

30. * - `http://localhost:8080/`

31. * - `http://localhost:8080/about-us/`

32. * - `http://localhost:8080/contact-us/`

33. * ... */

34. router = {

35. '/': 'index',

36. '/about-us/': 'overview',

37. '/contact-us/': 'contact'

38. };

39. /* ...ou à n'importe quoi finissant par `/`

40. * `http://localhost:8080/.+/`. */

41. file = router[request.url] || 'error';

42. /* Si l'adresse est trouvée dans `router`,

43. * la `response` sera valide et en `200` sinon

44. * ce sera une page inexistante d'erreur `404`. */

45. statusCode = (router[request.url]) ? 200 : 404;

46. /* Récupération de la structure globale de

47. * chaque page dans le fichier `layout.htm`. */

48. fs.readFile('layout.htm', function (err, layout) {

49. if (err) {

50. /* Information en cas d'erreur. */

51. console.log('We cannot open layout file.', err);

52. /* Renvoi d'une page serveur 500 en cas d'erreur. */

53. response.writeHead(500, {});

54. /* Fin de la transaction. */

55. response.end('');

56. }

57. /* Ouverture du code isomorphique correspondant aux pages :

58. * - `views/index.htm`    si `http://localhost:8080/`            est demandée

59. * - `views/overview.htm` si `http://localhost:8080/about-us/`   est demandée

60. * - `views/contact.htm`  si `http://localhost:8080/contact-us/` est demandée

61. * - `views/error.htm`    si `http://localhost:8080/.+/`         est demandée. */

62. fs.readFile('views/' + file + '.htm', 'utf-8', function (err, content) {

63. var dom = new JSDOM(layout);

64. if (err) {

65. /* Information en cas d'erreur. */

66. console.log('We cannot open ' + file + ' view file.', err);

67. }

68. /* Récupération de la balise `<base href="MyBase" />` */

69. dom.window.document.getElementsByTagName('base')[0]

70. /* et changement en `<base href="http://localhost:8080/" />`. */

71. .setAttribute('href', 'http://' + httpDomain + ':' + httpPort + '/');

72. /* Récupération de la balise `<div class="layout"></div>` */

73. dom.window.document.getElementsByClassName('layout')[0]

74. /* et changement de leur contenu par le contenu

75. * généré à partir d'appels isomorphiques des fichiers :

76. * - `require('./views/index.js')(<contenu de `views/index.htm`>, <objet window virtuel>)` ou

77. * - `require('./views/overview.js')(<contenu de `views/overview.htm`>, <objet window virtuel>)` ou

78. * - `require('./views/contact.js')(<contenu de `views/contact.htm`>, <objet window virtuel>)` ou

79. * - `require('./views/error.js')(<contenu de `views/error.htm`>, <objet window virtuel>)` */

80. .innerHTML = require('./views/' + file + '.js')(content, dom.window)

81. /* et contenu dans la propriété `template`

82. * (par ex. : `'<div class="layout"><h1>Welco[...]</ul></div>'`). */

83. .template;

84. /* Création des entêtes de réponse HTTP

85. * pour un fichier HTML

86. * soit en code `200` soit `404`. */

87. response.writeHead(statusCode, {

88. 'Content-Type': 'text/html; charset=utf-8'

89. });

90. /* Fin de la transaction avec envoi

91. * du fichier complet (par ex. `'<!DOCTYPE html><html lang="en"><head>[...]

92. * <div class="layout"><h1>Welco[...]</ul></div>[...]

93. * </body></html>'`). */

94. response.end(dom.serialize());

95. });

96. });

97. /* Cas de toutes les autres demandes du navigateur

98. * fait pour récupérer directement les fichiers

99. * de ressources statiques. */

100. } else {

101. /* Retrait du `/` de départ pour tentative

102. * d'ouverture du fichier. (par ex.  la requête

103. * `/javascripts/client.js` tentera d'ouvrir le

104. * fichier `javascripts/client.js`). */

105. file = request.url.slice(1);

106. /* Ouverture du fichier statique demandé */

107. fs.readFile(file, 'utf-8', function (err, content) {

108. /* Par défaut on estime que le fichier est trouvé... */

109. statusCode = 200;

110. /* et n'a pas de `'Content-type'` particulier */

111. contentType = {};

112. /* Association d'un fichier de `'Content-type'`

113. * par `application/javascript` si l'extension

114. * du fichier est `'.js'`. */

115. if (/\.js$/g.test(file)) {

116. contentType = {

117. 'Content-Type': 'application/javascript; charset=utf-8'

118. };

119. }

120. /* Association d'un fichier de `'Content-type'`

121. * par `text/html` si l'extension

122. * du fichier est `'.htm'`. */

123. if (/\.htm$/g.test(file)) {

124. contentType = {

125. 'Content-Type': 'text/html; charset=utf-8'

126. };

127. }

128. if (err) {

129. /* Si le ficher demandé n'existe pas

130. * on retourne un fichier en erreur

131. * 400 à contenu vide.*/

132. statusCode = 404;

133. contentType = {};

134. content = '';

135. /* Information en cas d'erreur */

136. console.log('We cannot open ' + file + ' asset file.', err);

137. }

138. /* Création des entêtes de réponse HTTP

139. * pour un fichier statique

140. * soit en code `200` soit `404`. */

141. response.writeHead(statusCode, contentType);

142. /* Fin de la transaction avec envoi

143. * du contenu du fichier s'il existe

144. * ou d'un contenu vide s'il n'existe pas. */

145. response.end(content);

146. });

147. }

148. /* Démarrage du serveur web */

149. }).listen(httpPort, function () {

150. /* Envoi d'un message à la console côté serveur

151. * quand le serveur est démarré et prêt à répondre

152. * aux demandes du client. */

153. console.log('Server listening on: http://' + httpDomain +':' + httpPort + '/');

154. });

IV-C - Les fichiers isomporphiques

À ce stade, le fichier server.js va retourner une réponse HTTP différente à votre navigateur en fonction de l'adresse demandée.

- Pour http://localhost:8080/, ce sont les fichiers de vue views/index.html et de modèle views/index.js qui vont être impliqués.

- Pour http://localhost:8080/about-us/, ce sont les fichiers de vue views/overview.html et de modèle views/overview.js qui vont être impliqués.

- Pour http://localhost:8080/contact-us/, ce sont les fichiers de vue views/contact.html et de modèle views/contact.js qui vont être impliqués.

- Et pour http://localhost:8080/.+/ (n'importe quelle adresse finissant par /), ce sont les fichiers de vue views/error.html et de modèle views/error.js qui vont être impliqués.

Pour cela, nous allons créer ces fichiers dans notre structure existante :

1. isomorphism/

2. ├─ javascripts/

3. │  ├─ isomorphic.js

4. │  ├─ isomorphic.mjs

5. │  ├─ operation.js

6. │  └─ operation.mjs

7. ├─ node_molules/

8. │  ├─ ...

9. ├─ views/

10. │  ├─ contact.htm

11. │  ├─ contact.js

12. │  ├─ error.htm

13. │  ├─ error.js

14. │  ├─ index.htm

15. │  ├─ index.js

16. │  ├─ overview.htm

17. │  └─ overview.js

18. ├─ es5.htm

19. ├─ es6.htm

20. ├─ server.js

21. └─ package.json

22. └─ package-lock.json

et les remplir comme suit :

views/index.htm (code source)

1. <!-- Template HTML qui sera rempli par

2. `views/index.js`. -->

3. <h1>MyTitle</h1>

4. <p>MyText</p>

5. <ul>

6. <li><a href="MyLinkHref">MyLinkContent</a></li>

7. <li><a href="MyLinkHref">MyLinkContent</a></li>

8. <li><a href="MyLinkHref">MyLinkContent</a></li>

9. </ul>

views/index.js (code source)

1. /* Utilisation de l'export CommonJS de Node.js. */

2. module.exports = function (template, window) {

3. /* Création d'un espace pour manipuler un fragment HTML... */

4. var body = window.document.implementation.createHTMLDocument().body,

5. /* Préparation des liens pour injection. */

6. links = [{

7. href: './about-us/',

8. content: 'Go to about page'

9. }, {

10. href: './contact-us/',

11. content: 'Go to contact page'

12. }, {

13. href: './error/',

14. content: 'Try an error page'

15. }];

16. /* ...lu depuis le fichier `views/index.htm`. */

17. body.innerHTML = template;

18. /* Injection du titre. */

19. body.getElementsByTagName('h1')[0].textContent = 'Welcome';

20. /* Injection du contenu. */

21. body.getElementsByTagName('p')[0].textContent = 'This is the welcome page!';

22. /* Injection des liens. */

23. Array.prototype.forEach.call(body.getElementsByTagName('a'), function (a, i) {

24. a.textContent = links[i].content;

25. a.setAttribute('href', links[i].href);

26. });

27. return {

28. template: body.innerHTML

29. };

30. };

views/overview.htm (code source)

1. <!-- Idem que pour `views/index.htm`. -->

2. <h1>MyTitle</h1>

3. <p>MyText</p>

4. <p><a href="MyLinkHref">MyLinkContent</a></p>

views/overview.js (code source)

1. /* Idem que pour `views/index.js`. */

2. module.exports = function (template, window) {

3. var body = window.document.implementation.createHTMLDocument().body,

4. a;

5. body.innerHTML = template;

6. body.getElementsByTagName('h1')[0].textContent = 'About this website';

7. body.getElementsByTagName('p')[0].textContent = 'The goal of this website is to provide a way to run isomporphique from scratch!';

8. a = body.getElementsByTagName('a')[0];

9. a.textContent = 'Back to the home';

10. a.setAttribute('href', './');

11. return {

12. template: body.innerHTML

13. };

14. };

views/contact.htm (code source)

1. <!-- Idem que pour `views/index.htm`. -->

2. <h1>MyTitle</h1>

3. <p>MyText</p>

4. <p><a href="MyLinkHref">MyLinkContent</a></p>

views/contact.js (code source)

1. /* Idem que pour `views/index.js`. */

2. module.exports = function (template, window) {

3. var body = window.document.implementation.createHTMLDocument().body,

4. a;

5. body.innerHTML = template;

6. a = body.getElementsByTagName('a')[0];

7. a.textContent = 'Back to the home';

8. a.setAttribute('href', './');

9. body.getElementsByTagName('h1')[0].textContent = 'Contact US';

10. body.getElementsByTagName('p')[0].innerHTML = 'You can contact us by using the following email: <a href="mailto:bruno.lesieur@gmail.com">bruno.lesieur@gmail.com</a>';

11. return {

12. template: body.innerHTML

13. };

14. };

views/error.htm (code source)

1. <!-- Idem que pour `views/index.htm`. -->

2. <h1>MyTitle</h1>

3. <p>MyText</p>

4. <p><a href="MyLinkHref">MyLinkContent</a></p>

views/error.js (code source)

1. /* Idem que pour `views/index.js`. */

2. module.exports = function (template, window) {

3. var body = window.document.implementation.createHTMLDocument().body,

4. a;

5. body.innerHTML = template;

6. body.getElementsByTagName('h1')[0].textContent = 'Error page';

7. body.getElementsByTagName('p')[0].textContent = 'This is the error page...';

8. a = body.getElementsByTagName('a')[0];

9. a.textContent = 'Back to the home';

10. a.setAttribute('href', './');

11. return {

12. template: body.innerHTML

13. };

14. };

Comprenez bien qu'à ce stade, toutes les nouvelles pages que vous ajouterez se rempliront avec une partie vue représentée par le HTML pour l'affichage de la page et une partie modèle pour les actions que vous ferez sur cette vue (ici, ajouter des textes). Ce code fonctionne aussi bien en étant appelé depuis le serveur qu'en étant appelé depuis le client. Il est donc parfaitement isomorphique.

IV-D - Le navigateur web

À partir d'ici, vous pouvez naviguer sur le site et le parcourir en utilisant les liens à l'adresse http://localhost:8080/. Si vous regardez dans la console de votre navigateur (F12 > Console), vous verrez juste que le fichier http://localhost:8080/javascripts/client.js n'est pas chargé.

GET http://localhost:8080/javascripts/client.js 404 (Not Found)

Vous constaterez également que changer de page se fait en rechargeant le navigateur pour chaque page.

C'est ici que va entrer en jeu la partie cliente dont le but va être d'exécuter les fichiers isomorphiques contenus dans le dossier views mais côté client. C'est grâce à cela que l'on sera capable de changer de page dynamiquement sans rechargement de page grâce aux appels XMLHttpRequest. Le fait de reprendre la main côté client sur la page courante s'appelle l'hydratation. Et en réalité, changer de page revient seulement à faire exécuter le couple .htm / .js directement dans le navigateur et simuler un changement de page avec pushState et l'évènement popstate.

Nous allons donc remplir le fichier client.js, qui lui, n'est compatible que du côté client :

1. isomorphism/

2. ├─ javascripts/

3. │  ├─ client.js

4. │  ├─ isomorphic.js

5. │  ├─ isomorphic.mjs

6. │  ├─ operation.js

7. │  └─ operation.mjs

8. ├─ node_molules/

9. │  ├─ ...

10. ├─ views/

11. │  ├─ contact.htm

12. │  ├─ contact.js

13. │  ├─ error.htm

14. │  ├─ error.js

15. │  ├─ index.htm

16. │  ├─ index.js

17. │  ├─ overview.htm

18. │  └─ overview.js

19. ├─ es5.htm

20. ├─ es6.htm

21. ├─ server.js

22. └─ package.json

23. └─ package-lock.json

avec le contenu suivant :

javascripts/client.js (code source)

1. /* Sortir de la portée globale

2. * pour notre code personnel afin

3. * d'éviter des conflits.

4. */

5. ;(function () {

6. /* Les pages navigables sont :

7. * - `http://localhost:8080/`

8. * - `http://localhost:8080/about-us/`

9. * - `http://localhost:8080/contact-us/`

10. * ... */

11. var router = {

12. '/': 'index',

13. '/about-us/': 'overview',

14. '/contact-us/': 'contact'

15. },

16. /* ...et celle envoyant un contenu en erreur sont : `/`

17. * `http://localhost:8080/.+/`. */

18. file = router[location.pathname] || 'error';

19. /* Compatiblilité CommonJS simple. */

20. window.module = {};

21. /* Gestion de la navigation dans l'historique

22. * notamment en cliquant sur le bouton « Retour »

23. * du navigateur. */

24. window.addEventListener('popstate', function () {

25. /* Récupération de l'URL après retour en

26. * arrière ou en avant dans l'historique. */

27. file = router[location.pathname] || 'error';

28. /* Puis récupération du bon couple `.htm` / `.js`

29. * en provenance de `views`. */

30. changeRoute(file, true);

31. });

32. /* Gestion du changement de page sans rechargement

33. * à partir du fichier de destination. `animate` permet

34. * de savoir si l'hydratation va être faite avec un effet

35. * d'animation ou non. */

36. function changeRoute(file, animate) {

37. /* Récupération de la vue et du modèle isomorphique.

38. * `file` vaut soit `index`, `overview` ou `contact`

39. * en fonction de ce que détecte `router` comme

40. * page courante. */

41. Promise.all([

42. /* On fait une demande XMLHttpRequest

43. * avec `fetch` qui retourne une promesse

44. * puis on transforme le résultat au format texte. */

45. fetch('views/' + file + '.htm').then(x => x.text()),

46. fetch('views/' + file + '.js').then(x => x.text())

47. ]).then(function (result) {

48. /* Récupération d'une référence sur le contenu de

49. * la page à hydrater. */

50. var layout = document.getElementsByClassName('layout'),

51. /* Récupération des fichiers `.htm` et `.js`

52. * en retour de promesse. */

53. view = result[0],

54. model = result[1],

55. /* Exécution côté client des fichiers

56. * en provenance du serveur. */

57. content = eval(model)(view, window);

58. /* Ajout du nouveau contenu dans une `div`

59. * différente pour faire une animation si

60. * demandé. */

61. if (animate) {

62. /* Ajout de la nouvelle page après la

63. * page courante. */

64. layout = layout[layout.length - 1];

65. layout.insertAdjacentHTML("afterend", '<div class="layout">' + content.template + "</div>");

66. /* Ajout de la classe indiquant

67. * l'animation CSS3 a été exécutée. */

68. layout.classList.add('change');

69. /* Retrait de la page d'où l'on vient

70. * à la fin de l'animation. */

71. setTimeout(function () {

72. layout.parentNode.removeChild(layout);

73. }, 1000);

74. /* Hydratation simple du contenu existant

75. * si pas d'animation. */

76. } else {

77. layout.innerHTML = content.template;

78. }

79. /* Faire changer la page sans rechargement

80. * à tous les liens présents dans la page. */

81. Array.prototype.forEach.call(document.getElementsByTagName('a'), function (a) {

82. /* Pour chaque lien, lors du clic. */

83. a.addEventListener('click', function (e) {

84. /* Pas de changement de page... */

85. e.preventDefault();

86. /* ...mais changement d'URL de la page. */

87. history.pushState(null, 'Isomporphic example', document.getElementsByTagName('base')[0].getAttribute('href') + a.getAttribute('href'));

88. /* La page à charger étant choisie par le routeur */

89. /* en se basant sur la nouvelle URL. */

90. file = router[location.pathname] || 'error';

91. /* Changement de page. */

92. changeRoute(file, true);

93. });

94. });

95. });

96. }

97. /* Hydratation de la page appelant `javascripts/client.js`

98. * avec le bon couple `.htm` / `.js` */

99. changeRoute(file, false);

100. }());

À partir de maintenant, depuis n'importe quelle page affichée en tapant l'URL dans la barre d'adresse, c'est le serveur qui répondra par retour HTTP grâce au fichier server.js. En fouillant la source HTML de votre page, vous constaterez que la page est correctement générée et peut donc être indexée par les moteurs de recherche. Une fois sur une page, le fichier javascripts/client.js va s'exécuter, hydratant le DOM actuel et permettant aux liens de changer de page sans rechargement, mais en appelant seulement les fragments isomorphiques pour les exécuter sur place (par le navigateur). Le résultat est un changement de page dynamique que vous pouvez apprécier grâce à l'animation de transition CSS mise en place dans layout.htm.

Vous pouvez tester l'hydratation cliente grâce à la mockup que vous trouverez en live grâce au système GitHub Pages : exemple d'hydratation côté client.

V - Conclusion

Vous en savez plus maintenant sur les mécanismes d'utilisation des Modules ECMAScript ou CommonJS / Node.js pour créer des applications web isomorphiques !

Bien entendu, le code actuel est loin d'être pratique pour la maintenance et n'est ni optimisé pour l'hydratation cliente (actuellement on jette le DOM et on le recrée au lieu de réellement l'hydrater), ni optimisé pour la charge serveur (on pourrait utiliser du cache côté serveur pour ne faire générer les rendus d'une page qu'une fois toutes les X secondes, minutes ou même heures en fonction des zones statiques ou dynamiques des pages).

On se demandera comment gérer plus simplement l'injection de texte dans les templates plutôt que de manipuler le DOM, comment faire fonctionner du code avec des évènements JavaScript côté serveur ? Si c'est possible ? Comment mélanger différents types de modules ?

Toutes ces solutions sont adressées plus ou moins simplement avec l'utilisation de l'écosystème Vue (par ex. webpack pour la partie cliente, Nuxt pour la partie serveur et Vue.js pour la partie isomorphique).

Pour ma part, pour passer à l'étape supérieure, tout en comprenant ce que vous faites (pour de l'isomorphisme aux petits oignons), je vous propose de vous tourner vers le couple Vue / NodeAtlas (un framework basé sur Express et Socket.io). Vue et NodeAtlas vous permettront de réaliser des sites réactifs et isomorphiques facilement et progressivement. Essayez avec l'article Vue + NodeAtlas : de l'art du SSR ou Rendu Côté Serveur avec JavaScript qui vous expliquera les bases.

Et cerise sur le gâteau, les documentations de Vue, Nuxt et NodeAtlas sont toutes en français, traduites par votre serviteur !

Vous pouvez obtenir l'intégralité des sources de ce tutoriel sur ce dépôt GitHub : Haeresis/import-export-require-isomorphism.

VI - Remerciements

Nous remercions Bruno Lesieur qui nous a autorisés à publier ce tutoriel.

Nous remercions également Winjerome pour la mise au gabarit et Fabien pour la correction orthographique.