@eleven-am/nestjs-storage/dist/providers/s3BaseStorage.js

A NestJS module for uploading files to cloud storage providers

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.S3BaseStorage = void 0;
const baseStorage_1 = require("./baseStorage");
const aws = require("aws-sdk");
class S3BaseStorage extends baseStorage_1.BaseStorage {
    constructor({ provider, options, }) {
        super(provider);
        this.storage = new aws.S3({
            ...options,
            region: options.region || 'auto',
            signatureVersion: 'v4',
        });
        this.bucket = options.bucket;
    }
    async createFolder(path) {
        await this.storage
            .putObject({
            Bucket: this.bucket,
            Key: path,
            Body: Buffer.alloc(0),
        })
            .promise();
        return this.getFileOrFolder(path);
    }
    async deleteFileOrFolder(fileId) {
        await this.storage
            .deleteObject({
            Bucket: this.bucket,
            Key: fileId,
        })
            .promise();
        return true;
    }
    async getFileOrFolder(fileId) {
        const data = await this.storage
            .getObject({
            Bucket: this.bucket,
            Key: fileId,
        })
            .promise();
        return this.parseFile(fileId, data);
    }
    moveFileOrFolder(fileId, newPath) {
        return new Promise((resolve, reject) => {
            this.storage
                .copyObject({
                Bucket: this.bucket,
                CopySource: `${this.bucket}/${fileId}`,
                Key: newPath,
            })
                .promise()
                .then(() => {
                return this.deleteFileOrFolder(fileId);
            })
                .then(() => {
                resolve(this.getFileOrFolder(newPath));
            })
                .catch((error) => {
                reject(error);
            });
        });
    }
    async putFile(path, data) {
        const params = {
            Bucket: this.bucket,
            Key: path,
            Body: data,
        };
        const s3Data = await this.storage.upload(params).promise();
        return this.getFileOrFolder(s3Data.Key);
    }
    readFile(fileId) {
        return new Promise((resolve, reject) => {
            this.storage
                .getObject({
                Bucket: this.bucket,
                Key: fileId,
            })
                .promise()
                .then((data) => {
                resolve(data.Body);
            })
                .catch((error) => {
                reject(error);
            });
        });
    }
    readFolder(folderId) {
        return new Promise((resolve, reject) => {
            this.storage
                .listObjectsV2({
                Bucket: this.bucket,
                Prefix: folderId,
            })
                .promise()
                .then((data) => {
                const files = data.Contents?.map((file) => {
                    return this.parseFile(file.Key || '', file);
                });
                resolve(files || []);
            })
                .catch((error) => {
                reject(error);
            });
        });
    }
    renameFileOrFolder(fileId, newName) {
        return this.moveFileOrFolder(fileId, newName);
    }
    getSignedUrl(fileId, expires) {
        return new Promise((resolve, reject) => {
            this.storage.getSignedUrl('getObject', {
                Bucket: this.bucket,
                Key: fileId,
                Expires: expires || 60 * 60 * 24 * 7,
            }, (err, url) => {
                if (err) {
                    reject(err);
                }
                else {
                    resolve(url);
                }
            });
        });
    }
    readRootFolder() {
        return this.readFolder('');
    }
    async streamFile(fileId, range) {
        const file = await this.getFileOrFolder(fileId);
        const { headers } = this.buildRange(range, file);
        const stream = this.storage
            .getObject({
            Bucket: this.bucket,
            Key: fileId,
            Range: range,
        })
            .createReadStream();
        return {
            stream,
            headers: headers,
        };
    }
    parseFile(fileId, data) {
        return {
            name: fileId,
            path: fileId,
            size: 'Size' in data
                ? data.Size
                : 'ContentLength' in data
                    ? data.ContentLength
                    : 0,
            mimeType: 'ContentType' in data ? data.ContentType : null,
            isFolder: false,
            modifiedAt: data.LastModified || new Date(),
        };
    }
}
exports.S3BaseStorage = S3BaseStorage;
//# sourceMappingURL=s3BaseStorage.js.map