Archiver

a streaming interface for archive generation

ArchiveStream
archiverjs/node-archiverwww.archiverjs.comarchiver

README

Archiver


A streaming interface for archive generation

Visit the API documentation for a list of all methods available.

Install


  1. ``` sh
  2. npm install archiver --save
  3. ```

Quick Start


  1. ``` js
  2. // require modules
  3. const fs = require('fs');
  4. const archiver = require('archiver');

  6. // create a file to stream archive data to.
  7. const output = fs.createWriteStream(__dirname + '/example.zip');
  8. const archive = archiver('zip', {
  9.   zlib: { level: 9 } // Sets the compression level.
  10. });

  12. // listen for all archive data to be written
  13. // 'close' event is fired only when a file descriptor is involved
  14. output.on('close', function() {
  15.   console.log(archive.pointer() + ' total bytes');
  16.   console.log('archiver has been finalized and the output file descriptor has closed.');
  17. });

  19. // This event is fired when the data source is drained no matter what was the data source.
  20. // It is not part of this library but rather from the NodeJS Stream API.
  21. // @see: https://nodejs.org/api/stream.html#stream_event_end
  22. output.on('end', function() {
  23.   console.log('Data has been drained');
  24. });

  26. // good practice to catch warnings (ie stat failures and other non-blocking errors)
  27. archive.on('warning', function(err) {
  28.   if (err.code === 'ENOENT') {
  29.     // log warning
  30.   } else {
  31.     // throw error
  32.     throw err;
  33.   }
  34. });

  36. // good practice to catch this error explicitly
  37. archive.on('error', function(err) {
  38.   throw err;
  39. });

  41. // pipe archive data to the file
  42. archive.pipe(output);

  44. // append a file from stream
  45. const file1 = __dirname + '/file1.txt';
  46. archive.append(fs.createReadStream(file1), { name: 'file1.txt' });

  48. // append a file from string
  49. archive.append('string cheese!', { name: 'file2.txt' });

  51. // append a file from buffer
  52. const buffer3 = Buffer.from('buff it!');
  53. archive.append(buffer3, { name: 'file3.txt' });

  55. // append a file
  56. archive.file('file1.txt', { name: 'file4.txt' });

  58. // append files from a sub-directory and naming it `new-subdir` within the archive
  59. archive.directory('subdir/', 'new-subdir');

  61. // append files from a sub-directory, putting its contents at the root of archive
  62. archive.directory('subdir/', false);

  64. // append files from a glob pattern
  65. archive.glob('file*.txt', {cwd:__dirname});

  67. // finalize the archive (ie we are done appending files but streams have to finish yet)
  68. // 'close', 'end' or 'finish' may be fired right after calling this method so register to them beforehand
  69. archive.finalize();
  70. ```

Formats


Archiver ships with out of the box support for TAR and ZIP archives.

You can register additional formats with registerFormat.

You can check if format already exists before to register a new one with isRegisteredFormat.

_Formats will be changing in the future to implement a middleware approach._