fetch-blob

A Blob implementation in Node.js, originally from node-fetch.

Use the built-in Blob in Node.js 18 and later.

Installation

1npm install fetch-blob

1  import {Readable} from 'stream'
2  const stream = Readable.from(blob.stream())

Usage

1// Ways to import
2import { Blob } from 'fetch-blob'
3import { File } from 'fetch-blob/file.js'
4
5const { Blob } = await import('fetch-blob')
6
7
8// Ways to read the blob:
9const blob = new Blob(['hello, world'])
10
11await blob.text()
12await blob.arrayBuffer()
13for await (let chunk of  blob.stream()) { ... }
14blob.stream().getReader().read()
15blob.stream().getReader({mode: 'byob'}).read(view)

Blob part backed up by filesystem

fetch-blob/from.js comes packed with tools to convert any filepath into either a Blob or a File It will not read the content into memory. It will only stat the file for last modified date and file size.

1// The default export is sync and use fs.stat to retrieve size & last modified as a blob
2import {File, Blob, blobFrom, blobFromSync, fileFrom, fileFromSync} from 'fetch-blob/from.js'
3
4const fsFile = fileFromSync('./2-GiB-file.bin', 'application/octet-stream')
5const fsBlob = await blobFrom('./2-GiB-file.mp4')
6
7// Not a 4 GiB memory snapshot, just holds references
8// points to where data is located on the disk
9const blob = new Blob([fsFile, fsBlob, 'memory', new Uint8Array(10)])
10console.log(blob.size) // ~4 GiB

blobFrom|blobFromSync|fileFrom|fileFromSync(path, [mimetype])

Creating a temporary file on the disk

(requires FinalizationRegistry - node v14.6)

When using both createTemporaryBlob and createTemporaryFile then you will write data to the temporary folder in their respective OS. The arguments can be anything that fsPromises.writeFile supports. NodeJS v14.17.0+ also supports writing (async)Iterable streams and passing in a AbortSignal, so both NodeJS stream and whatwg streams are supported. When the file have been written it will return a Blob/File handle with a references to this temporary location on the disk. When you no longer have a references to this Blob/File anymore and it have been GC then it will automatically be deleted.

This files are also unlinked upon exiting the process.

1import { createTemporaryBlob, createTemporaryFile } from 'fetch-blob/from.js'
2
3const req = new Request('https://httpbin.org/image/png')
4const res = await fetch(req)
5const type = res.headers.get('content-type')
6const signal = req.signal
7let blob = await createTemporaryBlob(res.body, { type, signal })
8// const file = createTemporaryBlob(res.body, 'img.png', { type, signal })
9blob = undefined // loosing references will delete the file from disk

• createTemporaryBlob(data, { type, signal })
• createTemporaryFile(data, FileName, { type, signal, lastModified })

Creating Blobs backed up by other async sources

Our Blob & File class are more generic then any other polyfills in the way that it can accept any blob look-a-like item An example of this is that our blob implementation can be constructed with parts coming from BlobDataItem (aka a filepath) or from buffer.Blob, It dose not have to implement all the methods - just enough that it can be read/understood by our Blob implementation. The minium requirements is that it has Symbol.toStringTag, size, slice(), stream() methods (the stream method can be as simple as being a sync or async iterator that yields Uint8Arrays. If you then wrap it in our Blob or File new Blob([blobDataItem]) then you get all of the other methods that should be implemented in a blob or file (aka: text(), arrayBuffer() and type and a ReadableStream)

An example of this could be to create a file or blob like item coming from a remote HTTP request. Or from a DataBase

See the MDN documentation and tests for more details of how to use the Blob.