@push.rocks/smartfile
Version:
High-level file representation classes (SmartFile, StreamFile, VirtualDirectory) for efficient in-memory file management in Node.js using TypeScript. Works seamlessly with @push.rocks/smartfs for filesystem operations.
208 lines • 17 kB
JavaScript
import * as plugins from './plugins.js';
import { Readable, Writable } from 'stream';
/**
* The StreamFile class represents a file as a stream.
* It allows creating streams from a file path, a URL, or a buffer.
* Use SmartFileFactory to create instances of this class.
*/
export class StreamFile {
// STATIC
static async fromPath(filePath, smartFs) {
if (!smartFs) {
throw new Error('No SmartFs instance available. Create StreamFile through SmartFileFactory.');
}
const streamSource = async (streamFileArg) => {
return await streamFileArg.smartFs.file(filePath).readStream();
};
const streamFile = new StreamFile(streamSource, filePath, smartFs);
streamFile.multiUse = true;
streamFile.byteLengthComputeFunction = async () => {
const stats = await smartFs.file(filePath).stat();
return stats.size;
};
return streamFile;
}
static async fromUrl(url, smartFs) {
const streamSource = async (streamFileArg) => {
const response = await plugins.smartrequest.SmartRequest.create()
.url(url)
.get();
const responseStream = response.stream();
if (!responseStream) {
throw new Error(`No response stream available for ${url}`);
}
return responseStream;
};
const streamFile = new StreamFile(streamSource, undefined, smartFs);
streamFile.multiUse = true;
streamFile.byteLengthComputeFunction = async () => {
const response = await plugins.smartrequest.SmartRequest.create()
.url(url)
.accept('binary')
.get();
const buffer = Buffer.from(await response.arrayBuffer());
return buffer.length;
};
return streamFile;
}
static fromBuffer(buffer, relativeFilePath, smartFs) {
const streamSource = async (streamFileArg) => {
const stream = new Readable();
stream.push(buffer);
stream.push(null); // End of stream
return stream;
};
const streamFile = new StreamFile(streamSource, relativeFilePath, smartFs);
streamFile.multiUse = true;
streamFile.byteLengthComputeFunction = async () => buffer.length;
return streamFile;
}
/**
* Creates a StreamFile from an existing Readable stream with an option for multiple uses.
* @param stream A Node.js Readable stream.
* @param relativeFilePath Optional file path for the stream.
* @param multiUse If true, the stream can be read multiple times, caching its content.
* @param smartFs Optional SmartFs instance for filesystem operations
* @returns A StreamFile instance.
*/
static fromStream(stream, relativeFilePath, multiUse = false, smartFs) {
const streamSource = (streamFileArg) => {
if (streamFileArg.multiUse) {
// If multi-use is enabled and we have cached content, create a new readable stream from the buffer
const bufferedStream = new Readable();
bufferedStream.push(streamFileArg.cachedStreamBuffer);
bufferedStream.push(null); // No more data to push
return Promise.resolve(bufferedStream);
}
else {
return Promise.resolve(stream);
}
};
const streamFile = new StreamFile(streamSource, relativeFilePath, smartFs);
streamFile.multiUse = multiUse;
// If multi-use is enabled, cache the stream when it's first read
if (multiUse) {
const chunks = [];
stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
stream.on('end', () => {
streamFile.cachedStreamBuffer = Buffer.concat(chunks);
});
// It's important to handle errors that may occur during streaming
stream.on('error', (err) => {
console.error('Error while caching stream:', err);
});
}
return streamFile;
}
// INSTANCE
relativeFilePath;
streamSource;
smartFs;
// enable stream based multi use
cachedStreamBuffer;
multiUse = false;
used = false;
byteLengthComputeFunction;
constructor(streamSource, relativeFilePath, smartFs) {
this.streamSource = streamSource;
this.relativeFilePath = relativeFilePath;
this.smartFs = smartFs;
}
// METHODS
checkMultiUse() {
if (!this.multiUse && this.used) {
throw new Error('This stream can only be used once.');
}
this.used = true;
}
/**
* Creates a new readable stream from the source.
*/
async createReadStream() {
const stream = await this.streamSource(this);
// Check if it's a Web ReadableStream and convert to Node.js Readable
if (stream && typeof stream.getReader === 'function') {
// This is a Web ReadableStream, convert it to Node.js Readable
return Readable.fromWeb(stream);
}
// It's already a Node.js Readable stream
return stream;
}
/**
* Writes the stream to the disk at the specified path.
* @param filePathArg The file path where the stream should be written.
*/
async writeToDisk(filePathArg) {
if (!this.smartFs) {
throw new Error('No SmartFs instance available. Create StreamFile through SmartFileFactory.');
}
this.checkMultiUse();
const readStream = await this.createReadStream();
let writeStream = await this.smartFs.file(filePathArg).writeStream();
// Check if it's a Web WritableStream and convert to Node.js Writable
if (writeStream && typeof writeStream.getWriter === 'function') {
// This is a Web WritableStream, convert it to Node.js Writable
writeStream = Writable.fromWeb(writeStream);
}
return new Promise((resolve, reject) => {
readStream.pipe(writeStream);
readStream.on('error', reject);
writeStream.on('error', reject);
writeStream.on('finish', resolve);
});
}
async writeToDir(dirPathArg) {
if (!this.smartFs) {
throw new Error('No SmartFs instance available. Create StreamFile through SmartFileFactory.');
}
this.checkMultiUse();
if (!this.relativeFilePath) {
throw new Error('Cannot write stream to directory without a relative file path.');
}
const filePath = plugins.path.join(dirPathArg, this.relativeFilePath);
const dirPath = plugins.path.parse(filePath).dir;
await this.smartFs.directory(dirPath).recursive().create();
return this.writeToDisk(filePath);
}
async getContentAsBuffer() {
this.checkMultiUse();
const done = plugins.smartpromise.defer();
const readStream = await this.createReadStream();
const chunks = [];
readStream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
readStream.on('error', done.reject);
readStream.on('end', () => {
const contentBuffer = Buffer.concat(chunks);
done.resolve(contentBuffer);
});
return done.promise;
}
async getContentAsString(formatArg = 'utf8') {
const contentBuffer = await this.getContentAsBuffer();
return contentBuffer.toString(formatArg);
}
/**
* Returns the size of the file content in bytes.
*/
async getSize() {
if (this.byteLengthComputeFunction) {
return this.byteLengthComputeFunction();
}
else {
return null;
}
}
/**
* Converts the StreamFile to a SmartFile by loading content into memory
*/
async toSmartFile() {
const { SmartFile } = await import('./classes.smartfile.js');
const buffer = await this.getContentAsBuffer();
return new SmartFile({
path: this.relativeFilePath || 'stream',
contentBuffer: buffer,
base: process.cwd()
}, this.smartFs);
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.streamfile.js","sourceRoot":"","sources":["../ts/classes.streamfile.ts"],"names":[],"mappings":"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"}