Comment partager du code entre des applications node.js ?

Question

J'ai plusieurs applications dans node qui partagent toutes quelques modules que j'ai écrits. Ces modules ne sont pas disponibles via npm. J'aimerais pouvoir partager librement entre les applications, mais je ne veux pas copier les répertoires, ni compter sur Git pour le faire. Et je ne suis pas non plus très favorable à l'utilisation de liens symboliques pour ce faire.

J'aimerais organiser les répertoires de la manière suivante :

app1
 server.js
 node_modules
  (public modules from npm needed for app1)
 lib
  (my own modules specific to app1)

app2
 server.js
 node_modules
  (public modules from npm needed for app2)
 lib
  (my own modules specific to app2)

shared_lib
 (my own modules that are used in both app1 and app2)

Le problème que je rencontre est que les modules dans shared_lib semblent ne pas savoir où trouver les modules qui seront dans le répertoire node_modules de l'application dans laquelle ils s'exécutent. Du moins, je pense que c'est le problème.

Alors.... quelle est la bonne façon de faire cela en évitant d'avoir des doublons de fichiers ? (notez que je ne me soucie pas des doublons de choses dans node_modules, puisque ce n'est pas mon code, je ne les enregistre pas dans Git, etc).

Answer 1

La documentation npm recommande d'utiliser npm-link pour créer vos propres paquets Node.js localement, puis les mettre à la disposition d'autres applications Node.js. Il s'agit d'un processus simple en quatre étapes.

Une procédure typique consisterait à créer d'abord un paquet avec la structure suivante :

  hello
  | index.js
  | package.json

Une mise en œuvre typique de ces fichiers serait la suivante :

index.js

  exports.world = function() {
     return('Hello World');
  }

package.json

  {
    "name": "hello",
    "version": "0.0.1",
    "private": true,
    "main": "index.js",
    "dependencies": {
    },
    "engines": {
    "node": "v0.6.x"
    }
  }

"private:true" garantit que npm refusera de publier le paquet. C'est un moyen d'éviter la publication accidentelle de paquets privés.

Ensuite, naviguez jusqu'à la racine de votre dossier de paquets Node.js et exécutez npm link pour lier le paquet globalement afin qu'il puisse être utilisé dans d'autres applications.

Pour utiliser ce paquet dans une autre application, par exemple "hello-world", avec la structure de répertoire suivante :

 hello-world
 | app.js

Naviguez jusqu'au dossier hello-world et exécutez :

 npm link hello

Vous pouvez maintenant l'utiliser comme n'importe quel autre paquet npm :

app.js

  var http = require('http');
  var hello = require('hello');

  var server = http.createServer(function(req, res) {
     res.writeHead(200);
     res.end(hello.world());
  });
  server.listen(8080);

Answer 2

J'ai réussi à faire fonctionner ce système en ayant node_modules à différents niveaux - le nœud se déplace alors automatiquement vers le haut jusqu'à ce qu'il trouve le module.

Notez qu'il n'est pas nécessaire de publier sur npm pour avoir un module dans node_modules - il suffit d'utiliser :

"private": true

À l'intérieur de chacun de vos package.json pour votre projet, j'aurais les fichiers suivants :

app1
 server.js
 node_modules
  (public modules from npm needed for app1)
  (private modules locally needed for app1)

app2
 server.js
 node_modules
  (public modules from npm needed for app2)
  (private modules locally needed for app2)

node_modules
  (public modules from npm needed for app1 & app2)
  (private modules locally for app1 & app2)

Le fait est que node.js a déjà un mécanisme pour gérer cela et qu'il est génial. Il suffit de le combiner avec l'astuce "private not on NPM" et c'est bon.

En bref, un :

require('somemodule')

À partir de l'application A ou B, le système remonte en cascade jusqu'à ce qu'il trouve le module, qu'il soit situé en bas ou en haut de l'échelle. En effet, cela vous permet de changer l'emplacement à chaud sans modifier les paramètres de l'application. require(...) déclarations.

documentation sur les modules node.js

Answer 3

Il suffit d'utiliser le chemin d'accès correct dans l'appel requis

Par exemple, dans server.js, ce serait :

var moduleName = require('../shared_lib/moduleName/module.js') ;

Il est important de savoir que dès que votre chemin est préfixé par '/', '../', ou './', le chemin est relatif au fichier appelant.

Pour plus d'informations sur le chargement des modules de nœuds, visitez le site : http://nodejs.org/docs/latest/api/modules.html

Answer 4

Oui, vous pouvez faire référence à shared_lib depuis app1, mais vous rencontrez alors un problème si vous voulez empaqueter et déployer app1 dans un autre environnement, tel qu'un serveur web sur AWS.

Dans ce cas, il est préférable d'installer vos modules dans shared_lib sur app1 et app2 en utilisant "npm install shared_lib/module". Cela installera également toutes les dépendances des modules de shared_lib dans app1 et app2 et gérera les conflits/duplicatas.

Voir cela : Comment installer un module NPM privé sans mon propre registre ?

Answer 5

Si vous consultez le site node.js docs vous verrez que Node.js comprend l'élément package.json également le format de fichier, du moins de manière superficielle.

En gros, si vous avez un répertoire nommé foo et dans ce répertoire se trouve un package.json avec la paire clé-valeur : "main": "myCode.js" Alors, si vous essayez de require("foo") et il trouve ce répertoire avec un package.json à l'intérieur, il utilisera alors foo/myCode.js pour les foo module.

Donc, avec votre structure de répertoire, si chaque librairie partagée a son propre répertoire avec un simple package.json à l'intérieur, alors vos applications peuvent obtenir les librairies partagées par :

var lib1 = require('../shared_lib/lib1');
var lib2 = require('../shared_lib/lib2');

Et cela devrait fonctionner pour ces deux applications.