Filesystem API easily usable with Promises and arrays
Last updated 8 days ago by franciscop .
MIT · Repository · Bugs · Original npm · Tarball · package.json
$ cnpm install files 
SYNC missed versions from official npm registry.

???? Files npm install files test badge

Version 2.0 released with ESM import { read } from "files"; ????, compatible with recent Node.js versions. If you prefer the require() way, please npm install files@1.

Node.js filesystem API easily usable with Promises and arrays:

import { read, walk } from 'files';

// Find all of the readmes
const readmes = await walk('demo')

// ['# files', '# sub-dir', ...]

Files is a better fs filesystem:

  • Works with 'utf-8' by default.
  • Uses Promises and works as expected with async/await.
  • Extends promises with swear so you can chain operations easily.
  • Absolute paths with the root as the running script.
  • Ignores the second parameter if it's not an object so you can work with arrays better like .map(read).

It's an ideal library if you have to build scripts with many file and folder operations since it's made to simplify those.


All of the methods return a promise (using swear):

function description
abs() retrieve the absolute path of the path
cat()* alias of read()
dir() get the directory of the path
exists() check whenever a file or folder exists
home() get the home directory
join() put several path parts together in a cross-browser way
list() list all of the files and folders of the path
ls()* alias of .list()
mkdir() create the specified directory
name() get the filename of the path
read() read the file from the specified path
remove() remove a file or folder (recursively)
stat() get some information about the current file
tmp() find the temporary directory or a folder inside
walk() recursively list all of the files and folders
write() create a new file or put data into a file

*Alias of another method

Swear package

All of the methods follow the swear promise extension. These are fully compatible with native promises:

// Using it as normal promises
const all = await list('demo');
const devFiles = all.filter(file => !/node_modules/.test(file));
// ['a.js', 'b.js', ...]

With the swear workflow, you can apply operations on the promise that will be queued and run on the eventual value:

const devFiles = await list('demo').filter(file => !/node_modules/.test(file));
// ['a.js', 'b.js', ...]

See how we applied the .filter() straight into the output of list(). Then we have to await for the whole thing to resolve since list() is async. If this seems a bit confusing, read along the examples and try it yourself.


abs(path:string, root=process.cwd():string) => :string

Retrieve the absolute path of the passed argument relative of the directory running the script:

// cd ~/me/projects/files/ && node index.js

console.log(await abs('demo'));
// /home/me/projects/files/demo

console.log(await abs('../../Documents'));
// /home/me/Documents

It will return the same string if the path is already absolute.

You can pass a second parameter to specify any base directory different from the executing environment:

// cd ~/me/projects/files && node ./demo/abs.js

// default; Relative to the place where the script is run
console.log(await abs('demo'));
// /home/me/projects/files/demo

// default; relative to the console location where the script is run
console.log(await abs('demo', process.cwd()));
// /home/me/projects/files/demo

// relative to the current directory (./demo)
console.log(await abs('demo', import.meta.url));
// /home/me/projects/files/demo/demo

If the second parameter is undefined, or if it's not a string, it will be completely ignored and the default of the current running dir will be used. This is great for looping on arrays or similar:

console.log(await ls('demo').map(abs));
// [ '/home/me/projects/files/a', '/home/me/projects/files/b' ]


alias of read().


dir(path:string) => :string

Returns the directory of the passed path:

console.log(await dir('~/hello/world.js'));
// /home/me/hello

If the path is already a directory, it returns the one that contains it; its parent:

console.log(await dir('~/hello/'));
// /home/me


exists(path:string) => :boolean

Check whenever a file or folder exists:

console.log(await exists(''));
// true

console.log(await exists(''));
// false

This cannot be used with .filter(), since in JS .filter() is sync and doesn't expect an array of promises to be returned.

To filter based on whether it exists or not, extend it to an array of promises, then filter that asynchronously and finally retrieve the original file:

const keeper = file => exists(file).then(keep => keep && file);
const existing = await Promise.all(['', ''].map(keeper));
console.log(existing.filter(file => file));

Swear interface: you can use swear to make your life a bit easier with its .filter(), which accepts promises:

console.log(await swear(['', '']).filter(exists));


home(arg1:string, arg2:string, ...) => :string

Find the home directory if called without arguments, or the specified directory inside the home folder as specified in the arguments.

console.log(await home());
// /home/me/

console.log(await home('demo'));
// /home/me/demo/

console.log(await home('demo', 'a'));
// /home/me/demo/a/

It will create the specified folder if it does not exist yet.

To make sure the new folder is empty, you can call remove() and mkdir() consecutively:

const dir = await home('demo').then(remove).then(mkdir);
// /home/me/demo/ (empty)


join(arg1:string, arg2:string, ...) => :string

Put several path segments together in a cross-browser way and return the absolute path:

console.log(await join('demo', 'a'));
// /home/me/projects/files/demo/a


list(path=process.cwd():string) => :Array(:string)

Get all of the files and folders of the specified directory into an array:

console.log(await list());
// ['/home/me/files/node_modules', '/home/me/files/demo/abs.js', ...]

To scan any other directory specify it as a parameter:

console.log(await list('demo'));
// ['/home/me/files/demo/a', '/home/me/files/demo/abs.js', ...]

Swear interface: you can iterate and treat the returned value as a normal array, except that you'll have to await at some point for the whole thing.

// Retrieve all of the files, filter for javascript and get their absolute paths
console.log(await list().filter(file => /\.js$/.test(file)).map(abs));
//  ['/home/me/projects/files/files.js', '/home/me/projects/files/files.test.js', ...]

Related methods:

  • walk() recursively list all of the files in a directory. Does not output directories.


alias of .list()


mkdir(path:string) => :string

Create the specified directory. If it already exists, do nothing. Returns the directory that was created.

// cd ~/projects/files && node index.js

console.log(await mkdir('demo/b'));
// /home/me/files/demo/b

Related methods:

  • exists(): check whether a directory exists.
  • remove(): remove a folder or file.
  • list(): read all the contents of a directory.


name(path:string) => :string

Get the filename of the passed path:

console.log(await name('~/hello/world.js'));
// world.js


read(path:string) => :string

Read the specified file contents into a string:

console.log(await read(''));
// # files ...

File reads are relative as always to the executing script. It expects a single argument so you can easily put an array on it:

// Read two files manually
console.log(await Promise.all(['', ''].map(read)));
// ['# A', '# B']

// Read all markdown files in all subfolders:
const allFiles = await walk();
const mdFiles = allFiles.filter(file => /\.md$/.test(file));
console.log(await Promise.all(;
// ['# A', '# B', ...]

It also follows the swear specification, so you can perform any normal string operations on it:

// Find all the secondary headers in a markdown file
console.log(await read('').split('\n').filter(/^##\s+/));
// ['## cat()', '## dir()', ...]

// Read all markdown files in all subfolders
console.log(await walk().filter(/\.md$/).map(read)));
// ['# A', '# B', ...]


remove(path:string) => :string

Remove a file or folder (recursively) and return the absolute path that was removed

console.log(await remove(''));
// /home/me/projects/

console.log(await remove('~/old-project'));
// /home/me/old-project

Please be careful when using this, since there is no way of recovering deleted files.


stat(path:string) => :Object({

Get some information about the current path:

console.log(await stat().isDirectory());
// true (the current directory)

console.log(await stat('').isFile());
// true

console.log(await stat('').atime);
// 2018-08-27T23:42:16.206Z


swear(arg:any) => :any

This is the swear package exported here for convenience. It allows you to chain promises using the underlying value methods for convenience.

Example: reading some specific files if they exist without swear:

const keeper = file => exists(file).then(keep => keep && file);
const existing = await Promise.all(['', ''].map(keeper));

Reading the same files if they exist with swear:

console.log(await swear(['', '']).filter(exists).map(read));


tmp(arg1:string) => :string

Find the temporary directory. Find a subfolder if an argument is passed:

console.log(await tmp());
// /tmp/

console.log(await tmp('demo'));
// /tmp/demo/

console.log(await tmp('demo/a'));
// /tmp/demo/a/

It will create the specified folder if it does not exist yet.

To reuse a temp folder and make sure it's empty on each usage, you can call remove() and mkdir() consecutively:

const dir = await tmp('demo').then(remove).then(mkdir);
// /tmp/demo/ (empty)


walk(path:string) => :Array(:string)

Recursively list all of the files from the specified folder:

// Retrieve all files inside './demo'
console.log(await walk('demo'));
// ['/home/me/projects/files/demo/', '/home/me/projects/files/demo/a/', ...]

It will not return directories. You can then use filter to filter e.g. by filename:

// Retrieve the content of all markdown files inside demo
console.log(await walk('demo').filter(file => /\.md$/.test(file)).map(read));
// ['# Readme A', '# Me also', ...]


write(path:string, content:string) => :string

Create a new file or put data into a file that already exists. Returns the path of the file:

// Write to a file and then read its contents
console.log(await write('demo.txt', 'Hello!').then(read));
// 'Hello!'

Current Tags

  • 2.0.1                                ...           latest (8 days ago)

21 Versions

  • 2.0.1                                ...           8 days ago
  • 2.0.0                                ...           15 days ago
  • 1.1.0                                ...           5 months ago
  • 1.0.4                                ...           5 months ago
  • 1.0.3                                ...           5 months ago
  • 1.0.2                                ...           5 months ago
  • 1.0.1                                ...           6 months ago
  • 1.0.0                                ...           a year ago
  • 0.8.2                                ...           8 years ago
  • 0.8.1                                ...           8 years ago
  • 0.8.0                                ...           8 years ago
  • 0.7.1                                ...           8 years ago
  • 0.6.0                                ...           8 years ago
  • 0.5.5                                ...           8 years ago
  • 0.5.2                                ...           8 years ago
  • 0.5.1                                ...           8 years ago
  • 0.5.0                                ...           8 years ago
  • 0.4.0                                ...           8 years ago
  • 0.3.0                                ...           8 years ago
  • 0.2.0                                ...           8 years ago
  • 0.1.0                                ...           8 years ago
Maintainers (1)
Today 0
This Week 1
This Month 1
Last Day 0
Last Week 21
Last Month 64
Dependencies (2)
Dev Dependencies (3)

Copyright 2014 - 2016 © |