@appsemble/node-utils/s3.js

NodeJS utilities used by Appsemble internally.

import { buffer as streamToBuffer } from 'node:stream/consumers';
import { Client, S3Error } from 'minio';
import { logger } from './logger.js';
let s3Client;
export function initS3Client({ accessKey, endPoint, port = 9000, secretKey, useSSL = true, }) {
    try {
        s3Client = new Client({
            endPoint,
            port,
            useSSL,
            accessKey,
            secretKey,
        });
    }
    catch (error) {
        logger.error(error);
        throw error;
    }
}
async function ensureBucket(name) {
    try {
        const bucketExists = await s3Client.bucketExists(name);
        if (!bucketExists) {
            try {
                await s3Client.makeBucket(name);
            }
            catch (makeBucketError) {
                if (makeBucketError instanceof S3Error &&
                    makeBucketError.code === 'BucketAlreadyOwnedByYou') {
                    logger.warn(makeBucketError);
                    logger.info('This was probably called in an asynchronous batch upload.');
                }
                else {
                    throw makeBucketError;
                }
            }
        }
    }
    catch (error) {
        logger.error(error);
        throw error;
    }
}
export async function uploadS3File(bucket, key, content, size) {
    try {
        await ensureBucket(bucket);
        await s3Client.putObject(bucket, key, content, size);
    }
    catch (error) {
        logger.error(error);
        throw error;
    }
}
export async function uploadS3FileFromPath(bucket, key, path) {
    try {
        await ensureBucket(bucket);
        await s3Client.fPutObject(bucket, key, path);
    }
    catch (error) {
        logger.error(error);
        throw error;
    }
}
export async function getS3File(bucket, key) {
    try {
        return await s3Client.getObject(bucket, key);
    }
    catch (error) {
        logger.error(error);
        // @ts-expect-error 2322 null is not assignable to type (strictNullChecks) - Severe
        return null;
    }
}
export async function getS3FileBuffer(bucket, key) {
    try {
        const stream = await getS3File(bucket, key);
        // @ts-expect-error 2322 null is not assignable to type (strictNullChecks) - Severe
        return stream ? streamToBuffer(stream) : null;
    }
    catch (error) {
        logger.error(error);
        // @ts-expect-error 2322 null is not assignable to type (strictNullChecks) - Severe
        return null;
    }
}
export async function getS3FileStats(bucket, key) {
    try {
        return await s3Client.statObject(bucket, key);
    }
    catch (error) {
        logger.error(error);
        throw error;
    }
}
export async function deleteS3Files(bucket, keys) {
    try {
        await s3Client.removeObjects(bucket, keys);
    }
    catch (error) {
        if (error instanceof S3Error && error.code === 'NoSuchBucket') {
            logger.warn(`S3 bucket "${bucket}" does not exist; skipping deletion`);
            return;
        }
        logger.error(error);
        throw error;
    }
}
export async function deleteS3File(bucket, key) {
    await deleteS3Files(bucket, [key]);
}
export async function clearAllS3Buckets() {
    try {
        const buckets = await s3Client.listBuckets();
        for (const bucket of buckets) {
            const objectsStream = s3Client.listObjectsV2(bucket.name, '', true);
            const objects = [];
            for await (const o of objectsStream) {
                objects.push(o.name);
            }
            await s3Client.removeObjects(bucket.name, objects);
            await s3Client.removeBucket(bucket.name);
        }
    }
    catch (error) {
        logger.error(error);
        throw error;
    }
}
//# sourceMappingURL=s3.js.map