Gathering detailed insights and metrics for tmp
Installations
npm install tmpDeveloper Guide
BETA
Typescript
No
Module System
CommonJS
Min. Node Version
>=14.14
Node Version
14.19.3
NPM Version
6.14.17
Score
99.7
Supply Chain
99.5
Quality
77.9
Maintenance
100
Vulnerability
100
License
Releases
Unable to fetch releases
Contributors
34
Unable to fetch Contributors
Languages
2
JavaScript
Shell
JavaScript (99.04%)
Shell (0.96%)
Developer
raszi
Download Statistics
Total Downloads
8,525,927,717
Last Day
8,394,614
Last Week
42,982,721
Last Month
152,214,035
Last Year
2,057,668,053
GitHub Statistics
742 Stars
442 Commits
93 Forks
7 Watching
9 Branches
34 Contributors
Bundle Size
5.01 kB
Minified
2.01 kB
Minified + Gzipped
Maintainers
1
Package Meta Information
Latest Version
0.2.3
Package Id
tmp@0.2.3
Unpacked Size
53.08 kB
Size
13.97 kB
File Count
5
NPM Version
6.14.17
Node Version
14.19.3
Publised On
29 Feb 2024
Total Downloads
Cumulative downloads
Total Downloads
8,525,927,717
Last day
1.1%
8,394,614
Compared to previous day
Last week
0.5%
42,982,721
Compared to previous week
Last month
-16.6%
152,214,035
Compared to previous month
Last year
15.8%
2,057,668,053
Compared to previous year
Daily Downloads
Weekly Downloads
Monthly Downloads
Yearly Downloads
Dev Dependencies
5
Versions
Tmp
A simple temporary file and directory creator for node.js.
About
This is a widely used library to create temporary files and directories in a node.js environment.
Tmp offers both an asynchronous and a synchronous API. For all API calls, all the parameters are optional. There also exists a promisified version of the API, see tmp-promise.
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.
If you do not want to store your temporary directories and files in the standard OS temporary directory, then you are free to override that as well.
An Important Note on Previously Undocumented Breaking Changes
All breaking changes that had been introduced, i.e.
- tmpdir must be located under the system defined tmpdir root.
- Spaces being collapsed into single spaces
- Removal of all single and double quote characters
have been reverted in v0.2.2 and tmp should now behave as it did before the introduction of these breaking changes.
Other breaking changes, i.e.
- template must be relative to tmpdir
- name must be relative to tmpdir
- dir option must be relative to tmpdir
are still in place.
In order to override the system's tmpdir, you will have to use the newly introduced tmpdir option.
An Important Note on Compatibility
See the CHANGELOG for more information.
Version 0.2.3
- Node version <= 14.4 has been dropped.
- rimraf has been dropped from the dependencies
Version 0.2.2
Since version 0.2.2, all support for node version <= 14 has been dropped.
Version 0.1.0
Since version 0.1.0, all support for node versions < 0.10.0 has been dropped.
Most importantly, any support for earlier versions of node-tmp was also dropped.
If you still require node versions < 0.10.0, then you must limit your node-tmp dependency to versions below 0.1.0.
Version 0.0.33
Since version 0.0.33, all support for node versions < 0.8 has been dropped.
If you still require node version 0.8, then you must limit your node-tmp dependency to version 0.0.33.
For node versions < 0.8 you must limit your node-tmp dependency to versions < 0.0.33.
How to install
1npm install tmp
Usage
Please also check API docs.
Graceful cleanup
If graceful cleanup is set, tmp will remove all controlled temporary objects on process exit, otherwise the temporary objects will remain in place, waiting to be cleaned up on system restart or otherwise scheduled temporary object removal.
To enforce this, you can call the setGracefulCleanup() method:
1const tmp = require('tmp'); 2 3tmp.setGracefulCleanup();
Asynchronous file creation
Simple temporary file creation, the file will be closed and unlinked on process exit.
1const tmp = require('tmp'); 2 3tmp.file(function _tempFileCreated(err, path, fd, cleanupCallback) { 4 if (err) throw err; 5 6 console.log('File: ', path); 7 console.log('Filedescriptor: ', fd); 8 9 // If we don't need the file anymore we could manually call the cleanupCallback 10 // But that is not necessary if we didn't pass the keep option because the library 11 // will clean after itself. 12 cleanupCallback(); 13});
Synchronous file creation
A synchronous version of the above.
1const tmp = require('tmp'); 2 3const tmpobj = tmp.fileSync(); 4console.log('File: ', tmpobj.name); 5console.log('Filedescriptor: ', tmpobj.fd); 6 7// If we don't need the file anymore we could manually call the removeCallback 8// But that is not necessary if we didn't pass the keep option because the library 9// will clean after itself. 10tmpobj.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.
1const tmp = require('tmp'); 2 3tmp.dir(function _tempDirCreated(err, path, cleanupCallback) { 4 if (err) throw err; 5 6 console.log('Dir: ', path); 7 8 // Manual cleanup 9 cleanupCallback(); 10});
If you want to cleanup the directory even when there are entries in it, then
you can pass the unsafeCleanup option when creating it.
Synchronous directory creation
A synchronous version of the above.
1const tmp = require('tmp'); 2 3const tmpobj = tmp.dirSync(); 4console.log('Dir: ', tmpobj.name); 5// Manual cleanup 6tmpobj.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.
1const tmp = require('tmp'); 2 3tmp.tmpName(function _tempNameGenerated(err, path) { 4 if (err) throw err; 5 6 console.log('Created temporary filename: ', path); 7});
Synchronous filename generation
A synchronous version of the above.
1const tmp = require('tmp'); 2 3const name = tmp.tmpNameSync(); 4console.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.
1const tmp = require('tmp'); 2 3tmp.file({ mode: 0o644, prefix: 'prefix-', postfix: '.txt' }, function _tempFileCreated(err, path, fd) { 4 if (err) throw err; 5 6 console.log('File: ', path); 7 console.log('Filedescriptor: ', fd); 8});
Synchronous file creation
A synchronous version of the above.
1const tmp = require('tmp'); 2 3const tmpobj = tmp.fileSync({ mode: 0o644, prefix: 'prefix-', postfix: '.txt' }); 4console.log('File: ', tmpobj.name); 5console.log('Filedescriptor: ', tmpobj.fd);
Controlling the Descriptor
As a side effect of creating a unique file tmp gets a file descriptor that is
returned to the user as the fd parameter. The descriptor may be used by the
application and is closed when the removeCallback is invoked.
In some use cases the application does not need the descriptor, needs to close it without removing the file, or needs to remove the file without closing the descriptor. Two options control how the descriptor is managed:
discardDescriptor- iftruecausestmpto close the descriptor after the file is created. In this case thefdparameter is undefined.detachDescriptor- iftruecausestmpto return the descriptor in thefdparameter, but it is the application's responsibility to close it when it is no longer needed.
1const tmp = require('tmp'); 2 3tmp.file({ discardDescriptor: true }, function _tempFileCreated(err, path, fd, cleanupCallback) { 4 if (err) throw err; 5 // fd will be undefined, allowing application to use fs.createReadStream(path) 6 // without holding an unused descriptor open. 7});
1const tmp = require('tmp'); 2 3tmp.file({ detachDescriptor: true }, function _tempFileCreated(err, path, fd, cleanupCallback) { 4 if (err) throw err; 5 6 cleanupCallback(); 7 // Application can store data through fd here; the space used will automatically 8 // be reclaimed by the operating system when the descriptor is closed or program 9 // terminates. 10});
Asynchronous directory creation
Creates a directory with mode 0755, prefix will be myTmpDir_.
1const tmp = require('tmp'); 2 3tmp.dir({ mode: 0o750, prefix: 'myTmpDir_' }, function _tempDirCreated(err, path) { 4 if (err) throw err; 5 6 console.log('Dir: ', path); 7});
Synchronous directory creation
Again, a synchronous version of the above.
1const tmp = require('tmp'); 2 3const tmpobj = tmp.dirSync({ mode: 0750, prefix: 'myTmpDir_' }); 4console.log('Dir: ', tmpobj.name);
mkstemp like, asynchronously
Creates a new temporary directory with mode 0700 and filename like /tmp/tmp-nk2J1u.
IMPORTANT NOTE: template no longer accepts a path. Use the dir option instead if you
require tmp to create your temporary filesystem object in a different place than the
default tmp.tmpdir.
1const tmp = require('tmp'); 2 3tmp.dir({ template: 'tmp-XXXXXX' }, function _tempDirCreated(err, path) { 4 if (err) throw err; 5 6 console.log('Dir: ', path); 7});
mkstemp like, synchronously
This will behave similarly to the asynchronous version.
1const tmp = require('tmp'); 2 3const tmpobj = tmp.dirSync({ template: 'tmp-XXXXXX' }); 4console.log('Dir: ', tmpobj.name);
Asynchronous filename generation
Using tmpName() you can create temporary file names asynchronously.
The function accepts all standard options, e.g. prefix, postfix, dir, and so on.
You can also leave out the options altogether and just call the function with a callback as first parameter.
1const tmp = require('tmp'); 2 3const options = {}; 4 5tmp.tmpName(options, function _tempNameGenerated(err, path) { 6 if (err) throw err; 7 8 console.log('Created temporary filename: ', path); 9});
Synchronous filename generation
The tmpNameSync() function works similarly to tmpName().
Again, you can leave out the options altogether and just invoke the function without any parameters.
1const tmp = require('tmp'); 2const options = {}; 3const tmpname = tmp.tmpNameSync(options); 4console.log('Created temporary filename: ', tmpname);
Options
All options are optional :)
name: a fixed name that overrides random name generation, the name must be relative and must not contain path segmentsmode: the file mode to create with, falls back to0o600on file creation and0o700on directory creationprefix: the optional prefix, defaults totmppostfix: the optional postfixtemplate:mkstemplike filename template, no default, must includeXXXXXXonce for random name generation, e.g. 'foo-bar-XXXXXX'.dir: the optional temporary directory that must be relative to the system's default temporary directory. absolute paths are fine as long as they point to a location under the system's default temporary directory. Any directories along the so specified path must exist, otherwise a ENOENT error will be thrown upon access, as tmp will not check the availability of the path, nor will it establish the requested path for you.tmpdir: allows you to override the system's root tmp directorytries: how many times should the function try to get a unique filename before giving up, default3keep: signals that the temporary file or directory should not be deleted on exit, default isfalse- In order to clean up, you will have to call the provided
cleanupCallbackfunction manually.
- In order to clean up, you will have to call the provided
unsafeCleanup: recursively removes the created temporary directory, even when it's not empty. default isfalsedetachDescriptor: detaches the file descriptor, caller is responsible for closing the file, tmp will no longer try closing the file during garbage collectiondiscardDescriptor: discards the file descriptor (closes file, fd is -1), tmp will no longer try closing the file during garbage collection
No vulnerabilities found.
Reason
no dangerous workflow patterns detected
Reason
no binaries found in the repo
Reason
license file detected
Details
- Info: project has a license file: LICENSE:0
- Info: FSF or OSI recognized license: MIT License: LICENSE:0
Reason
5 existing vulnerabilities detected
Details
- Warn: Project is vulnerable to: GHSA-grv7-fg5c-xmjg
- Warn: Project is vulnerable to: GHSA-3xgq-45jj-v275
- Warn: Project is vulnerable to: GHSA-78xj-cgh5-2h22
- Warn: Project is vulnerable to: GHSA-2p57-rm9w-gvfp
- Warn: Project is vulnerable to: GHSA-f5x3-32g6-xq36
Reason
dependency not pinned by hash detected -- score normalized to 3
Details
- Warn: GitHub-owned GitHubAction not pinned by hash: .github/workflows/node.js.yml:24: update your workflow using https://app.stepsecurity.io/secureworkflow/raszi/node-tmp/node.js.yml/master?enable=pin
- Warn: GitHub-owned GitHubAction not pinned by hash: .github/workflows/node.js.yml:26: update your workflow using https://app.stepsecurity.io/secureworkflow/raszi/node-tmp/node.js.yml/master?enable=pin
- Info: 0 out of 2 GitHub-owned GitHubAction dependencies pinned
- Info: 1 out of 1 npmCommand dependencies pinned
Reason
Found 2/15 approved changesets -- score normalized to 1
Reason
detected GitHub workflow tokens with excessive permissions
Details
- Warn: no topLevel permission defined: .github/workflows/node.js.yml:1
- Info: no jobLevel write permissions found
Reason
0 commit(s) and 0 issue activity found in the last 90 days -- score normalized to 0
Reason
no effort to earn an OpenSSF best practices badge detected
Reason
security policy file not detected
Details
- Warn: no security policy file detected
- Warn: no security file to analyze
- Warn: no security file to analyze
- Warn: no security file to analyze
Reason
project is not fuzzed
Details
- Warn: no fuzzer integrations found
Reason
SAST tool is not run on all commits -- score normalized to 0
Details
- Warn: 0 commits out of 20 are checked with a SAST tool
Score
3.6
/10
Last Scanned on 2025-01-20
The Open Source Security Foundation is a cross-industry collaboration to improve the security of open source software (OSS). The Scorecard provides security health metrics for open source projects.
Learn More