tmp-promise

What is tmp-promise?

The tmp-promise npm package provides a simple and intuitive way to create temporary files and directories in a Node.js environment with promise-based asynchronous control flow. It is a wrapper around the 'tmp' package, offering a promise-based API instead of a callback-based one, which can be more convenient when using async/await syntax.

What are tmp-promise's main functionalities?

Create a temporary file

This feature allows you to create a temporary file. The 'file' method returns a promise that resolves with an object containing the path to the file and a cleanup function to delete the file when you're done with it.

const tmp = require('tmp-promise');

(async () => {
  const file = await tmp.file();
  console.log('File path:', file.path);
  await file.cleanup();
})();

Create a temporary directory

This feature allows you to create a temporary directory. The 'dir' method returns a promise that resolves with an object containing the path to the directory and a cleanup function to remove the directory when no longer needed.

const tmp = require('tmp-promise');

(async () => {
  const dir = await tmp.dir();
  console.log('Directory path:', dir.path);
  await dir.cleanup();
})();

Custom options for file/directory creation

This feature allows you to specify custom options such as file prefix, postfix, and other options supported by the 'tmp' package when creating a temporary file or directory.

const tmp = require('tmp-promise');

(async () => {
  const fileWithOpts = await tmp.file({ prefix: 'myPrefix_', postfix: '.txt' });
  console.log('File path with options:', fileWithOpts.path);
  await fileWithOpts.cleanup();
})();

Other packages similar to tmp-promise

temp

The 'temp' package is another npm package for managing temporary files and directories. It provides a similar API to 'tmp' but does not have built-in promise support, which means it might require more boilerplate code when used with async/await.

tempfile

The 'tempfile' package is a minimalistic npm package that helps you create temporary files. Unlike 'tmp-promise', it does not provide functions for creating temporary directories or cleanup mechanisms.

temp-write

The 'temp-write' package allows you to write data to a temporary file. It is more focused on writing content to files rather than managing temporary files and directories, and it does not provide a cleanup function.

README

tmp-promise

A simple utility for creating temporary files or directories.

The tmp package with promises support. If you want to use tmp with async/await then this helper might be for you.

This documentation is mostly copied from that package's - but with promise usage instead of callback usage adapted.

Installation

npm i tmp-promise

About

This adds promises support to a widely used library. This package is used to create temporary files and directories in a Node.js environment.

tmp-promise offers both an asynchronous and a synchronous API. For all API calls, all the parameters are optional.

Internally, tmp uses crypto for determining random file names, or, when using templates, a six letter random identifier. And just in case that you do not have that much entropy left on your system, tmp will fall back to pseudo random numbers.

You can set whether you want to remove the temporary file on process exit or not, and the destination directory can also be set.

tmp-promise also uses promise disposers to provide a nice way to perform cleanup when you're done working with the files.

Usage (API Reference)

Asynchronous file creation

Simple temporary file creation, the file will be closed and unlinked on process exit.

With Node.js 10 and es - modules:

import { file } from 'tmp-promise'

(async () => {
  const {fd, path, cleanup} = await file();
  // work with file here in fd
  cleanup();
})(); 

Or the older way:

var tmp = require('tmp-promise');

tmp.file().then(o => {  
  console.log("File: ", o.path);
  console.log("Filedescriptor: ", o.fd);
  
  // If we don't need the file anymore we could manually call cleanup
  // But that is not necessary if we didn't pass the keep option because the library
  // will clean after itself.
  o.cleanup();
});

Simple temporary file creation with a disposer:

With Node.js 10 and es - modules:

import { withFile } from 'tmp-promise'

withFile(async ({path, fd}) => {
  // when this function returns or throws - release the file 
  await doSomethingWithFile(db);
});

Or the older way:

tmp.withFile(o => {
  console.log("File: ", o.path);
  console.log("Filedescriptor: ", o.fd);
  // the file remains opens until the below promise resolves
  return somePromiseReturningFn();
}).then(v => {
  // file is closed here automatically, v is the value of somePromiseReturningFn
});

Synchronous file creation

A synchronous version of the above.

var tmp = require('tmp-promise');

var tmpobj = tmp.fileSync();
console.log("File: ", tmpobj.name);
console.log("Filedescriptor: ", tmpobj.fd);
  
// If we don't need the file anymore we could manually call the removeCallback
// But that is not necessary if we didn't pass the keep option because the library
// will clean after itself.
tmpobj.removeCallback();

Note that this might throw an exception if either the maximum limit of retries for creating a temporary name fails, or, in case that you do not have the permission to write to the directory where the temporary file should be created in.

Asynchronous directory creation

Simple temporary directory creation, it will be removed on process exit.

If the directory still contains items on process exit, then it won't be removed.

var tmp = require('tmp-promise');

tmp.dir().then(o => {
  console.log("Dir: ", o.path);
  
  // Manual cleanup
  o.cleanup();
});

If you want to cleanup the directory even when there are entries in it, then you can pass the unsafeCleanup option when creating it.

You can also use a disposer here which takes care of cleanup automatically:

var tmp = require('tmp-promise');

tmp.withDir(o => {
  console.log("Dir: ", o.path);
  
  // automatic cleanup when the below promise resolves
  return somePromiseReturningFn(); 
}).then(v => {
  // the directory has been cleaned here
});

Synchronous directory creation

A synchronous version of the above.

var tmp = require('tmp-promise');

var tmpobj = tmp.dirSync();
console.log("Dir: ", tmpobj.name);
// Manual cleanup
tmpobj.removeCallback();

Note that this might throw an exception if either the maximum limit of retries for creating a temporary name fails, or, in case that you do not have the permission to write to the directory where the temporary directory should be created in.

Asynchronous filename generation

It is possible with this library to generate a unique filename in the specified directory.

var tmp = require('tmp-promise');

tmp.tmpName().then(path => {
    console.log("Created temporary filename: ", path);
});

Synchronous filename generation

A synchronous version of the above.

var tmp = require('tmp-promise');

var name = tmp.tmpNameSync();
console.log("Created temporary filename: ", name);

Advanced usage

Asynchronous file creation

Creates a file with mode 0644, prefix will be prefix- and postfix will be .txt.

var tmp = require('tmp-promise');

tmp.file({ mode: 0644, prefix: 'prefix-', postfix: '.txt' }).then(o => {
  console.log("File: ", o.path);
  console.log("Filedescriptor: ", o.fd); 
});

Synchronous file creation

A synchronous version of the above.

var tmp = require('tmp-promise');

var tmpobj = tmp.fileSync({ mode: 0644, prefix: 'prefix-', postfix: '.txt' });
console.log("File: ", tmpobj.name);
console.log("Filedescriptor: ", tmpobj.fd);

Asynchronous directory creation

Creates a directory with mode 0755, prefix will be myTmpDir_.

var tmp = require('tmp-promise');

tmp.dir({ mode: 0750, prefix: 'myTmpDir_' }).then(o => {
  console.log("Dir: ", o.path);
});

Synchronous directory creation

Again, a synchronous version of the above.

var tmp = require('tmp-promise');

var tmpobj = tmp.dirSync({ mode: 0750, prefix: 'myTmpDir_' });
console.log("Dir: ", tmpobj.name);

mkstemp like, asynchronously

Creates a new temporary directory with mode 0700 and filename like /tmp/tmp-nk2J1u.

var tmp = require('tmp-promise');
tmp.dir({ template: '/tmp/tmp-XXXXXX' }).then(console.log);

mkstemp like, synchronously

This will behave similarly to the asynchronous version.

var tmp = require('tmp-promise');

var tmpobj = tmp.dirSync({ template: '/tmp/tmp-XXXXXX' });
console.log("Dir: ", tmpobj.name);

Asynchronous filename generation

The tmpName() function accepts the prefix, postfix, dir, etc. parameters also:

var tmp = require('tmp-promise');

tmp.tmpName({ template: '/tmp/tmp-XXXXXX' }).then(path =>
    console.log("Created temporary filename: ", path);
);

Synchronous filename generation

The tmpNameSync() function works similarly to tmpName().

var tmp = require('tmp-promise');
var tmpname = tmp.tmpNameSync({ template: '/tmp/tmp-XXXXXX' });
console.log("Created temporary filename: ", tmpname);

Graceful cleanup

One may want to cleanup the temporary files even when an uncaught exception occurs. To enforce this, you can call the setGracefulCleanup() method:

var tmp = require('tmp');

tmp.setGracefulCleanup();

Options

All options are optional :)

• mode: the file mode to create with, it fallbacks to 0600 on file creation and 0700 on directory creation
• prefix: the optional prefix, fallbacks to tmp- if not provided
• postfix: the optional postfix, fallbacks to .tmp on file creation
• template: mkstemp like filename template, no default
• dir: the optional temporary directory, fallbacks to system default (guesses from environment)
• tries: how many times should the function try to get a unique filename before giving up, default 3
• keep: signals that the temporary file or directory should not be deleted on exit, default is false, means delete
  • Please keep in mind that it is recommended in this case to call the provided cleanupCallback function manually.
• unsafeCleanup: recursively removes the created temporary directory, even when it's not empty. default is false