Besoin de compresser un répertoire entier en utilisant Node.js

J'ai besoin de compresser un répertoire entier en utilisant Node.js. J'utilise actuellement node-zip et chaque fois que le processus s'exécute, il génère un fichier ZIP non valide (comme vous pouvez le voir dans ce problème Github ).

Existe-t-il une autre option, meilleure, Node.js qui me permettra de compresser un répertoire?

EDIT: j'ai fini par utiliser l' archiveur

writeZip = function(dir,name) {
var zip = new JSZip(),
    code = zip.folder(dir),
    output = zip.generate(),
    filename = ['jsd-',name,'.zip'].join('');

fs.writeFileSync(baseDir + filename, output);
console.log('creating ' + filename);
};

exemple de valeur pour les paramètres:

dir = /tmp/jsd-<randomstring>/
name = <randomstring>

MISE À JOUR: Pour ceux qui posent des questions sur l'implémentation que j'ai utilisée, voici un lien vers mon téléchargeur :

J'ai fini par utiliser l' archiveur lib. Fonctionne très bien.

Exemple

var file_system = require('fs');
var archiver = require('archiver');

var output = file_system.createWriteStream('target.zip');
var archive = archiver('zip');

output.on('close', function () {
    console.log(archive.pointer() + ' total bytes');
    console.log('archiver has been finalized and the output file descriptor has closed.');
});

archive.on('error', function(err){
    throw err;
});

archive.pipe(output);

// append files from a sub-directory and naming it `new-subdir` within the archive (see docs for more options):
archive.directory(source_dir, false);
archive.finalize();

Je ne prétends pas montrer quelque chose de nouveau, je veux juste résumer les solutions ci-dessus pour ceux qui aiment utiliser les fonctions Promise dans leur code (comme moi).

const archiver = require('archiver');

/**
 * @param {String} source
 * @param {String} out
 * @returns {Promise}
 */
function zipDirectory(source, out) {
  const archive = archiver('zip', { zlib: { level: 9 }});
  const stream = fs.createWriteStream(out);

  return new Promise((resolve, reject) => {
    archive
      .directory(source, false)
      .on('error', err => reject(err))
      .pipe(stream)
    ;

    stream.on('close', () => resolve());
    archive.finalize();
  });
}

J'espère que cela aidera quelqu'un;)

Utilisez l' child_processAPI native de Node pour ce faire.

Pas besoin de bibliothèques tierces. Deux lignes de code.

const child_process = require("child_process");
child_process.execSync(`zip -r DESIRED_NAME_OF_ZIP_FILE_HERE *`, {
  cwd: PATH_TO_FOLDER_YOU_WANT_ZIPPED_HERE
});

J'utilise l'API synchrone. Vous pouvez utiliser child_process.exec(path, options, callback)si vous avez besoin d'async. Il y a beaucoup plus d'options que de simplement spécifier le CWD pour affiner davantage vos demandes. Voir la documentation exec / execSync .

Remarque: cet exemple suppose que l'utilitaire zip est installé sur votre système (au moins, il est fourni avec OSX). Certains systèmes d'exploitation peuvent ne pas avoir d'utilitaire installé (c'est-à-dire que le runtime AWS Lambda n'en a pas). Dans ce cas, vous pouvez facilement obtenir le binaire de l'utilitaire zip ici et le conditionner avec le code source de votre application (pour AWS Lambda, vous pouvez également le conditionner dans une couche Lambda), ou vous devrez soit utiliser un module tiers (dont il y en a beaucoup sur NPM). Je préfère la première approche, car l'utilitaire ZIP est essayé et testé depuis des décennies.

Archive.bulkest désormais obsolète, la nouvelle méthode à utiliser pour cela est glob :

var fileName =   'zipOutput.zip'
var fileOutput = fs.createWriteStream(fileName);

fileOutput.on('close', function () {
    console.log(archive.pointer() + ' total bytes');
    console.log('archiver has been finalized and the output file descriptor has closed.');
});

archive.pipe(fileOutput);
archive.glob("../dist/**/*"); //some glob pattern here
archive.glob("../dist/.htaccess"); //another glob pattern
// add as many as you like
archive.on('error', function(err){
    throw err;
});
archive.finalize();

Pour inclure tous les fichiers et répertoires:

archive.bulk([
  {
    expand: true,
    cwd: "temp/freewheel-bvi-120",
    src: ["**/*"],
    dot: true
  }
]);

Il utilise node-glob ( https://github.com/isaacs/node-glob ) en dessous, donc toute expression correspondante compatible avec cela fonctionnera.

Ceci est une autre bibliothèque qui zippe le dossier en une seule ligne: zip-local

var zipper = require('zip-local');

zipper.sync.zip("./hello/world/").compress().save("pack.zip");

Pour diriger le résultat vers l'objet de réponse (scénarios où il est nécessaire de télécharger le zip plutôt que de stocker localement)

 archive.pipe(res);

Les conseils de Sam pour accéder au contenu du répertoire ont fonctionné pour moi.

src: ["**/*"]

Adm-zip a des problèmes lors de la simple compression d'une archive existante https://github.com/cthackers/adm-zip/issues/64 ainsi que la corruption lors de la compression de fichiers binaires.

J'ai également rencontré des problèmes de corruption de compression avec node-zip https://github.com/daraosn/node-zip/issues/4

node-archiver est le seul qui semble bien fonctionner pour la compression, mais il n'a aucune fonctionnalité de décompression.

J'ai trouvé cette petite bibliothèque qui résume ce dont vous avez besoin.

npm install zip-a-folder

const zip-a-folder = require('zip-a-folder');
await zip-a-folder.zip('/path/to/the/folder', '/path/to/archive.zip');

https://www.npmjs.com/package/zip-a-folder

Comme il archivern'est pas compatible avec la nouvelle version de webpack depuis longtemps, je recommande d'utiliser zip-lib .

var zl = require("zip-lib");

zl.archiveFolder("path/to/folder", "path/to/target.zip").then(function () {
    console.log("done");
}, function (err) {
    console.log(err);
});

Vous pouvez essayer de manière simple:

Installer zip-dir:

npm install zip-dir

et utilisez-le

var zipdir = require('zip-dir');

let foldername =  src_path.split('/').pop() 
    zipdir(<<src_path>>, { saveTo: 'demo.zip' }, function (err, buffer) {

    });

J'ai fini par emballer l'archiveur pour émuler JSZip, car la refactorisation à travers mon projet ne demanderait pas trop d'efforts. Je comprends qu'Archiver n'est peut-être pas le meilleur choix, mais c'est parti.

// USAGE:
const zip=JSZipStream.to(myFileLocation)
    .onDone(()=>{})
    .onError(()=>{});

zip.file('something.txt','My content');
zip.folder('myfolder').file('something-inFolder.txt','My content');
zip.finalize();

// NodeJS file content:
    var fs = require('fs');
    var path = require('path');
    var archiver = require('archiver');

  function zipper(archive, settings) {
    return {
        output: null,
        streamToFile(dir) {
            const output = fs.createWriteStream(dir);
            this.output = output;
            archive.pipe(output);

            return this;
        },
        file(location, content) {
            if (settings.location) {
                location = path.join(settings.location, location);
            }
            archive.append(content, { name: location });
            return this;
        },
        folder(location) {
            if (settings.location) {
                location = path.join(settings.location, location);
            }
            return zipper(archive, { location: location });
        },
        finalize() {
            archive.finalize();
            return this;
        },
        onDone(method) {
            this.output.on('close', method);
            return this;
        },
        onError(method) {
            this.output.on('error', method);
            return this;
        }
    };
}

exports.JSzipStream = {
    to(destination) {
        console.log('stream to',destination)
        const archive = archiver('zip', {
            zlib: { level: 9 } // Sets the compression level.
        });
        return zipper(archive, {}).streamToFile(destination);
    }
};