@8ms/helpers 2.1.4 → 2.2.10

package/aws/s3/AwsS3Namespace.js

@@ -1,407 +1,364 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
+import { BaseNamespace } from "../../_class";
+import { isResponse200 } from "../server";
+import { getFolder, getStringFromStream } from "../../string";
+import { getBrotliCompressed, getBrotliDecompressed, getGzipCompressed, getGzipDecompressed } from "../../util/server";
+import { readFileDefault } from "./server";
+import cloneDeep from "lodash/cloneDeep";
+import { getToday, getYmdHisString } from "../../date";
+import get from "axios";
+export class AwsS3Namespace extends BaseNamespace {
+    ensureInit = async () => {
+        if (!this.client) {
+            try {
+                const { S3Client } = await import("@aws-sdk/client-s3");
+                this.client = new S3Client(this.config);
+            }
+            catch (e) {
+                throw new Error("AWS S3 Client not installed");
+            }
+        }
+    };
+    copy = async (fromBucket, fromKey, toBucket, toKey) => {
+        await this.ensureInit();
+        const { CopyObjectCommand } = await import("@aws-sdk/client-s3");
+        await this.client.send(new CopyObjectCommand({
+            Bucket: toBucket,
+            CopySource: encodeURIComponent(`${fromBucket}/${fromKey}`),
+            Key: toKey,
+        }));
+    };
+    deleteFile = async (bucket, key) => {
+        await this.ensureInit();
+        const { DeleteObjectCommand } = await import("@aws-sdk/client-s3");
+        await this.client.send(new DeleteObjectCommand({
+            Bucket: bucket,
+            Key: key,
+        }));
     };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
+    deleteFiles = async (bucket, keys) => {
+        await this.ensureInit();
+        const { DeleteObjectsCommand } = await import("@aws-sdk/client-s3");
+        await this.client.send(new DeleteObjectsCommand({
+            Bucket: bucket,
+            Delete: {
+                Objects: keys.map(key => ({
+                    Key: key,
+                })),
+            },
+        }));
+    };
+    deleteFolder = async (bucket, folder) => {
+        await this.ensureInit();
+        const { ListObjectsV2Command, DeleteObjectsCommand } = await import("@aws-sdk/client-s3");
+        const cleanFolder = getFolder(folder);
+        // Get a list of all files to be deleted
+        const apiResponse = await this.client.send(new ListObjectsV2Command({
+            Bucket: bucket,
+            Prefix: ("" === cleanFolder ? "" : cleanFolder + "/"),
+        }));
+        // No files to be deleted
+        if (apiResponse.Contents.length === 0) {
+            return;
+        }
+        // Map each of the files
+        const keys = apiResponse.Contents.map(file => ({ Key: file.Key }));
+        // Delete the files
+        await this.client.send(new DeleteObjectsCommand({
+            Bucket: bucket,
+            Delete: {
+                Objects: keys,
+            },
+        }));
+        // If we didn't get all files, run it again
+        if (apiResponse.IsTruncated) {
+            await this.deleteFolder(bucket, folder);
+        }
     };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AwsS3Namespace = void 0;
-const _class_1 = require("../../_class");
-const server_1 = require("../server");
-const string_1 = require("../../string");
-const server_2 = require("../../util/server");
-const server_3 = require("./server");
-const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
-const date_1 = require("../../date");
-const axios_1 = __importDefault(require("axios"));
-class AwsS3Namespace extends _class_1.BaseNamespace {
-    constructor() {
-        super(...arguments);
-        this.ensureInit = async () => {
-            if (!this.client) {
-                try {
-                    const { S3Client } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-s3")));
-                    this.client = new S3Client(this.config);
-                }
-                catch (e) {
-                    throw new Error("AWS S3 Client not installed");
-                }
+    /**
+     * List the files in the given bucket and option folder
+     */
+    listFiles = async (bucket, folder = "") => {
+        await this.ensureInit();
+        const { ListObjectsV2Command } = await import("@aws-sdk/client-s3");
+        const cleanFolder = getFolder(folder);
+        let response = [];
+        let valid = [];
+        const apiResponse = await this.client.send(new ListObjectsV2Command({
+            Bucket: bucket,
+            Delimiter: "/",
+            Prefix: ("" === cleanFolder ? "" : cleanFolder + "/"),
+        }));
+        // Ensure the data exists
+        if (undefined !== apiResponse["Contents"]) {
+            // Return an array of files
+            valid = apiResponse["Contents"].filter(content => {
+                const keyExploded = content["Key"].split("/");
+                return keyExploded[keyExploded.length - 1].indexOf(".") > -1;
+            });
+            if (valid.length) {
+                response = valid.map(entry => entry["Key"]);
             }
+        }
+        return response;
+    };
+    /**
+     * Fetch all the files within a given directory recursively
+     */
+    filesIteratively = async (bucket, folder) => {
+        await this.ensureInit();
+        const response = await this.iterateFolders(bucket, folder);
+        return response;
+    };
+    /**
+     * Sub function
+     */
+    iterateFolders = async (bucket, folder) => {
+        let response = [];
+        const folders = await this.listFolders(bucket, folder);
+        for (let i = 0; i < folders.length; i++) {
+            const subFolderFiles = await this.listFolders(bucket, `${folder}/${folders[i]}`);
+            const files = await this.listFiles(bucket, `${folder}/${folders[i]}`);
+            response = [
+                ...response,
+                ...files,
+                ...subFolderFiles,
+            ];
+        }
+        return response;
+    };
+    /**
+     * List the files in the given bucket and option folder.
+     */
+    listFolders = async (bucket, folder) => {
+        await this.ensureInit();
+        const { ListObjectsV2Command } = await import("@aws-sdk/client-s3");
+        const cleanFolder = getFolder(folder);
+        let response = [];
+        const apiResponse = await this.client.send(new ListObjectsV2Command({
+            Bucket: bucket,
+            Delimiter: "/",
+            Prefix: ("" === cleanFolder ? "" : cleanFolder + "/"),
+        }));
+        // Ensure the data exists
+        if (undefined !== apiResponse["CommonPrefixes"]) {
+            // Return an array of folders removing the trailing folder
+            response = apiResponse["CommonPrefixes"].map(prefix => {
+                // Remove the trailing slash then split by slash
+                const fileFolders = prefix.Prefix.slice(0, -1)
+                    .split("/");
+                // Return the last folder without a trailing slash
+                return fileFolders[fileFolders.length - 1];
+            });
+        }
+        return response;
+    };
+    move = async (fromBucket, fromKey, toBucket, toKey) => {
+        await this.ensureInit();
+        const { CopyObjectCommand, DeleteObjectCommand } = await import("@aws-sdk/client-s3");
+        await this.client.send(new CopyObjectCommand({
+            Bucket: toBucket,
+            CopySource: encodeURIComponent(`${fromBucket}/${fromKey}`),
+            Key: toKey,
+        }));
+        await this.client.send(new DeleteObjectCommand({
+            Bucket: fromBucket,
+            Key: fromKey,
+        }));
+    };
+    readBrotli = async (bucket, key, brotliOptions = {}, awsS3Options = {}) => {
+        await this.ensureInit();
+        const apiResponse = await this.readFile(bucket, key, awsS3Options);
+        // Cache exists and is still within our caching timeframe
+        if (undefined !== apiResponse.body) {
+            apiResponse.body = await getBrotliDecompressed(apiResponse.body, brotliOptions);
+        }
+        return apiResponse;
+    };
+    readJsonBrotli = async (bucket, key, brotliOptions = {}, awsS3Options = {}) => {
+        await this.ensureInit();
+        const apiResponse = await this.readFile(bucket, key, awsS3Options);
+        if (undefined !== apiResponse.body) {
+            apiResponse.body = await getBrotliDecompressed(apiResponse.body, brotliOptions);
+            apiResponse.body = JSON.parse(apiResponse.body) || null;
+        }
+        return apiResponse;
+    };
+    readBuffer = async (bucket, key) => {
+        await this.ensureInit();
+        const { GetObjectCommand } = await import("@aws-sdk/client-s3");
+        let response = {
+            ...readFileDefault,
+            buffer: undefined,
         };
-        this.copy = async (fromBucket, fromKey, toBucket, toKey) => {
-            await this.ensureInit();
-            const { CopyObjectCommand } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-s3")));
-            await this.client.send(new CopyObjectCommand({
-                Bucket: toBucket,
-                CopySource: encodeURIComponent(`${fromBucket}/${fromKey}`),
-                Key: toKey,
-            }));
-        };
-        this.deleteFile = async (bucket, key) => {
-            await this.ensureInit();
-            const { DeleteObjectCommand } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-s3")));
-            await this.client.send(new DeleteObjectCommand({
+        const apiResponse = await this.client.send(new GetObjectCommand({
+            Bucket: bucket,
+            Key: key,
+        }));
+        if (isResponse200(apiResponse)) {
+            const chunks = [];
+            // Store the response
+            response.buffer = await new Promise((resolve, reject) => {
+                // @ts-ignore
+                apiResponse.Body.on("data", (chunk) => chunks.push(chunk));
+                // @ts-ignore
+                apiResponse.Body.on("error", (err) => reject(err));
+                // @ts-ignore
+                apiResponse.Body.on("end", () => resolve(Buffer.concat(chunks)));
+            });
+        }
+        else {
+            throw new Error("Error reading file.");
+        }
+        return response;
+    };
+    fileExists = async (bucket, key) => {
+        await this.ensureInit();
+        let response = false;
+        try {
+            const { HeadObjectCommand } = await import("@aws-sdk/client-s3");
+            // Fetch from S3
+            const apiResponse = await this.client.send(new HeadObjectCommand({
                 Bucket: bucket,
                 Key: key,
             }));
-        };
-        this.deleteFiles = async (bucket, keys) => {
-            await this.ensureInit();
-            const { DeleteObjectsCommand } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-s3")));
-            await this.client.send(new DeleteObjectsCommand({
-                Bucket: bucket,
-                Delete: {
-                    Objects: keys.map(key => ({
-                        Key: key,
-                    })),
-                },
-            }));
-        };
-        this.deleteFolder = async (bucket, folder) => {
-            await this.ensureInit();
-            const { ListObjectsV2Command, DeleteObjectsCommand } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-s3")));
-            const cleanFolder = (0, string_1.getFolder)(folder);
-            // Get a list of all files to be deleted
-            const apiResponse = await this.client.send(new ListObjectsV2Command({
-                Bucket: bucket,
-                Prefix: ("" === cleanFolder ? "" : cleanFolder + "/"),
-            }));
-            // No files to be deleted
-            if (apiResponse.Contents.length === 0) {
-                return;
-            }
-            // Map each of the files
-            const keys = apiResponse.Contents.map(file => ({ Key: file.Key }));
-            // Delete the files
-            await this.client.send(new DeleteObjectsCommand({
-                Bucket: bucket,
-                Delete: {
-                    Objects: keys,
-                },
-            }));
-            // If we didn't get all files, run it again
-            if (apiResponse.IsTruncated) {
-                await this.deleteFolder(bucket, folder);
-            }
-        };
-        /**
-         * List the files in the given bucket and option folder
-         */
-        this.listFiles = async (bucket, folder = "") => {
-            await this.ensureInit();
-            const { ListObjectsV2Command } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-s3")));
-            const cleanFolder = (0, string_1.getFolder)(folder);
-            let response = [];
-            let valid = [];
-            const apiResponse = await this.client.send(new ListObjectsV2Command({
-                Bucket: bucket,
-                Delimiter: "/",
-                Prefix: ("" === cleanFolder ? "" : cleanFolder + "/"),
-            }));
-            // Ensure the data exists
-            if (undefined !== apiResponse["Contents"]) {
-                // Return an array of files
-                valid = apiResponse["Contents"].filter(content => {
-                    const keyExploded = content["Key"].split("/");
-                    return keyExploded[keyExploded.length - 1].indexOf(".") > -1;
-                });
-                if (valid.length) {
-                    response = valid.map(entry => entry["Key"]);
-                }
-            }
-            return response;
-        };
-        /**
-         * Fetch all the files within a given directory recursively
-         */
-        this.filesIteratively = async (bucket, folder) => {
-            await this.ensureInit();
-            const response = await this.iterateFolders(bucket, folder);
-            return response;
-        };
-        /**
-         * Sub function
-         */
-        this.iterateFolders = async (bucket, folder) => {
-            let response = [];
-            const folders = await this.listFolders(bucket, folder);
-            for (let i = 0; i < folders.length; i++) {
-                const subFolderFiles = await this.listFolders(bucket, `${folder}/${folders[i]}`);
-                const files = await this.listFiles(bucket, `${folder}/${folders[i]}`);
-                response = [
-                    ...response,
-                    ...files,
-                    ...subFolderFiles,
-                ];
-            }
-            return response;
-        };
-        /**
-         * List the files in the given bucket and option folder.
-         */
-        this.listFolders = async (bucket, folder) => {
-            await this.ensureInit();
-            const { ListObjectsV2Command } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-s3")));
-            const cleanFolder = (0, string_1.getFolder)(folder);
-            let response = [];
-            const apiResponse = await this.client.send(new ListObjectsV2Command({
-                Bucket: bucket,
-                Delimiter: "/",
-                Prefix: ("" === cleanFolder ? "" : cleanFolder + "/"),
-            }));
-            // Ensure the data exists
-            if (undefined !== apiResponse["CommonPrefixes"]) {
-                // Return an array of folders removing the trailing folder
-                response = apiResponse["CommonPrefixes"].map(prefix => {
-                    // Remove the trailing slash then split by slash
-                    const fileFolders = prefix.Prefix.slice(0, -1)
-                        .split("/");
-                    // Return the last folder without a trailing slash
-                    return fileFolders[fileFolders.length - 1];
-                });
-            }
-            return response;
-        };
-        this.move = async (fromBucket, fromKey, toBucket, toKey) => {
-            await this.ensureInit();
-            const { CopyObjectCommand, DeleteObjectCommand } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-s3")));
-            await this.client.send(new CopyObjectCommand({
-                Bucket: toBucket,
-                CopySource: encodeURIComponent(`${fromBucket}/${fromKey}`),
-                Key: toKey,
-            }));
-            await this.client.send(new DeleteObjectCommand({
-                Bucket: fromBucket,
-                Key: fromKey,
-            }));
-        };
-        this.readBrotli = async (bucket, key, brotliOptions = {}, awsS3Options = {}) => {
-            await this.ensureInit();
-            const apiResponse = await this.readFile(bucket, key, awsS3Options);
-            // Cache exists and is still within our caching timeframe
-            if (undefined !== apiResponse.body) {
-                apiResponse.body = await (0, server_2.getBrotliDecompressed)(apiResponse.body, brotliOptions);
-            }
-            return apiResponse;
-        };
-        this.readJsonBrotli = async (bucket, key, brotliOptions = {}, awsS3Options = {}) => {
-            await this.ensureInit();
-            const apiResponse = await this.readFile(bucket, key, awsS3Options);
-            if (undefined !== apiResponse.body) {
-                apiResponse.body = await (0, server_2.getBrotliDecompressed)(apiResponse.body, brotliOptions);
-                apiResponse.body = JSON.parse(apiResponse.body) || null;
-            }
-            return apiResponse;
-        };
-        this.readBuffer = async (bucket, key) => {
-            await this.ensureInit();
-            const { GetObjectCommand } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-s3")));
-            let response = {
-                ...server_3.readFileDefault,
-                buffer: undefined,
-            };
+            // If the status is 200 then it does exist
+            response = isResponse200(apiResponse);
+        }
+        catch (exception) {
+            response = false;
+        }
+        return response;
+    };
+    readFile = async (bucket, key, options = {}) => {
+        await this.ensureInit();
+        let response = cloneDeep(readFileDefault);
+        const today = getToday();
+        const midnight = getToday(true);
+        try {
+            response.now = today.toUnixInteger();
+            const { GetObjectCommand } = await import("@aws-sdk/client-s3");
+            //console.log('GetObjectCommand', GetObjectCommand);
             const apiResponse = await this.client.send(new GetObjectCommand({
                 Bucket: bucket,
                 Key: key,
+                ...options,
             }));
-            if ((0, server_1.isResponse200)(apiResponse)) {
-                const chunks = [];
-                // Store the response
-                response.buffer = await new Promise((resolve, reject) => {
-                    // @ts-ignore
-                    apiResponse.Body.on("data", (chunk) => chunks.push(chunk));
-                    // @ts-ignore
-                    apiResponse.Body.on("error", (err) => reject(err));
-                    // @ts-ignore
-                    apiResponse.Body.on("end", () => resolve(Buffer.concat(chunks)));
-                });
-            }
-            else {
-                throw new Error("Error reading file.");
-            }
-            return response;
-        };
-        this.fileExists = async (bucket, key) => {
-            await this.ensureInit();
-            let response = false;
-            try {
-                const { HeadObjectCommand } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-s3")));
-                // Fetch from S3
-                const apiResponse = await this.client.send(new HeadObjectCommand({
-                    Bucket: bucket,
-                    Key: key,
-                }));
-                // If the status is 200 then it does exist
-                response = (0, server_1.isResponse200)(apiResponse);
-            }
-            catch (exception) {
-                response = false;
+            //console.log('apiResponse', apiResponse);
+            if (isResponse200(apiResponse)) {
+                // Convert the date to unix
+                response.modified = getYmdHisString(apiResponse.LastModified);
+                // Convert stream into a string
+                response.body = await getStringFromStream(apiResponse.Body);
             }
-            return response;
-        };
-        this.readFile = async (bucket, key, options = {}) => {
-            await this.ensureInit();
-            let response = (0, cloneDeep_1.default)(server_3.readFileDefault);
-            const today = (0, date_1.getToday)();
-            const midnight = (0, date_1.getToday)(true);
-            try {
-                response.now = today.toUnixInteger();
-                const { GetObjectCommand } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-s3")));
-                //console.log('GetObjectCommand', GetObjectCommand);
-                const apiResponse = await this.client.send(new GetObjectCommand({
-                    Bucket: bucket,
-                    Key: key,
-                    ...options,
-                }));
-                //console.log('apiResponse', apiResponse);
-                if ((0, server_1.isResponse200)(apiResponse)) {
-                    // Convert the date to unix
-                    response.modified = (0, date_1.getYmdHisString)(apiResponse.LastModified);
-                    // Convert stream into a string
-                    response.body = await (0, string_1.getStringFromStream)(apiResponse.Body);
-                }
-            }
-            catch (error) {
-                response.body = null;
-                response.error = error;
-            }
-            return response;
-        };
-        this.readJson = async (bucket, key) => {
-            await this.ensureInit();
-            const apiResponse = await this.readFile(bucket, key);
+        }
+        catch (error) {
+            response.body = null;
+            response.error = error;
+        }
+        return response;
+    };
+    readJson = async (bucket, key) => {
+        await this.ensureInit();
+        const apiResponse = await this.readFile(bucket, key);
+        apiResponse.body = JSON.parse(apiResponse.body) || null;
+        return apiResponse;
+    };
+    readJsonGzip = async (bucket, key, gzipOptions = {}, awsS3Options = {}) => {
+        await this.ensureInit();
+        const apiResponse = await this.readFile(bucket, key, awsS3Options);
+        if (undefined !== apiResponse.body) {
+            apiResponse.body = await getGzipDecompressed(apiResponse.body, gzipOptions);
             apiResponse.body = JSON.parse(apiResponse.body) || null;
-            return apiResponse;
-        };
-        this.readJsonGzip = async (bucket, key, gzipOptions = {}, awsS3Options = {}) => {
-            await this.ensureInit();
-            const apiResponse = await this.readFile(bucket, key, awsS3Options);
-            if (undefined !== apiResponse.body) {
-                apiResponse.body = await (0, server_2.getGzipDecompressed)(apiResponse.body, gzipOptions);
-                apiResponse.body = JSON.parse(apiResponse.body) || null;
+        }
+        return apiResponse;
+    };
+    readGzip = async (bucket, key, gzipOptions = {}, awsS3Options = {}) => {
+        await this.ensureInit();
+        const apiResponse = await this.readFile(bucket, key, awsS3Options);
+        if (undefined !== apiResponse.body) {
+            apiResponse.body = await getGzipDecompressed(apiResponse.body, gzipOptions);
+        }
+        return apiResponse;
+    };
+    writeBrotli = async (bucket, key, data, brotliOptions = {}, awsS3Options = {}) => {
+        await this.ensureInit();
+        let finalData = data;
+        finalData = await getBrotliCompressed(finalData, brotliOptions);
+        const apiResponse = await this.writeFile(bucket, key, finalData, awsS3Options);
+        return apiResponse;
+    };
+    writeFile = async (bucket, key, data, options = {}) => {
+        await this.ensureInit();
+        const { PutObjectCommand } = await import("@aws-sdk/client-s3");
+        const apiResponse = await this.client.send(new PutObjectCommand({
+            Bucket: bucket,
+            Body: data,
+            Key: key,
+            ...options,
+        }));
+        return apiResponse;
+    };
+    writeJson = async (bucket, key, data, options = {}) => {
+        await this.ensureInit();
+        const apiResponse = await this.writeFile(bucket, key, JSON.stringify(data), options);
+        return apiResponse;
+    };
+    writeJsonGzip = async (bucket, key, data, gzipOptions = {}, awsS3Options = {}) => {
+        await this.ensureInit();
+        let finalData = JSON.stringify(data);
+        finalData = await getGzipCompressed(finalData, gzipOptions);
+        const apiResponse = await this.writeFile(bucket, key, finalData, awsS3Options);
+        return apiResponse;
+    };
+    writeGzip = async (bucket, key, data, gzipOptions = {}, awsS3Options = {}) => {
+        await this.ensureInit();
+        let finalData = data;
+        finalData = await getGzipCompressed(finalData, gzipOptions);
+        const apiResponse = await this.writeFile(bucket, key, finalData, awsS3Options);
+        return apiResponse;
+    };
+    /**
+     * Get a presigned post URL so we can upload directly to S3 via frontend.
+     */
+    presignedPost = async (props) => {
+        await this.ensureInit();
+        return new Promise(async (resolve, reject) => {
+            let response = null;
+            const formData = new FormData();
+            Object.entries({ fields: props.fields, file: props.file })
+                .forEach(([key, value]) => {
+                formData.append(key, value);
+            });
+            const upload = await fetch(props.url, {
+                method: "POST",
+                body: formData,
+            });
+            // Uploaded to S3
+            if (upload.ok) {
+                response = `https://${props.bucket}.s3.${this.config.region}.amazonaws.com/${props.key}`;
+                resolve(response);
             }
-            return apiResponse;
-        };
-        this.readGzip = async (bucket, key, gzipOptions = {}, awsS3Options = {}) => {
-            await this.ensureInit();
-            const apiResponse = await this.readFile(bucket, key, awsS3Options);
-            if (undefined !== apiResponse.body) {
-                apiResponse.body = await (0, server_2.getGzipDecompressed)(apiResponse.body, gzipOptions);
+            // Failed to upload to S3
+            else {
+                response = null;
+                reject(response);
             }
-            return apiResponse;
-        };
-        this.writeBrotli = async (bucket, key, data, brotliOptions = {}, awsS3Options = {}) => {
-            await this.ensureInit();
-            let finalData = data;
-            finalData = await (0, server_2.getBrotliCompressed)(finalData, brotliOptions);
-            const apiResponse = await this.writeFile(bucket, key, finalData, awsS3Options);
-            return apiResponse;
-        };
-        this.writeFile = async (bucket, key, data, options = {}) => {
-            await this.ensureInit();
-            const { PutObjectCommand } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-s3")));
-            const apiResponse = await this.client.send(new PutObjectCommand({
-                Bucket: bucket,
-                Body: data,
-                Key: key,
-                ...options,
-            }));
-            return apiResponse;
-        };
-        this.writeJson = async (bucket, key, data, options = {}) => {
-            await this.ensureInit();
-            const apiResponse = await this.writeFile(bucket, key, JSON.stringify(data), options);
-            return apiResponse;
-        };
-        this.writeJsonGzip = async (bucket, key, data, gzipOptions = {}, awsS3Options = {}) => {
-            await this.ensureInit();
-            let finalData = JSON.stringify(data);
-            finalData = await (0, server_2.getGzipCompressed)(finalData, gzipOptions);
-            const apiResponse = await this.writeFile(bucket, key, finalData, awsS3Options);
-            return apiResponse;
-        };
-        this.writeGzip = async (bucket, key, data, gzipOptions = {}, awsS3Options = {}) => {
-            await this.ensureInit();
-            let finalData = data;
-            finalData = await (0, server_2.getGzipCompressed)(finalData, gzipOptions);
-            const apiResponse = await this.writeFile(bucket, key, finalData, awsS3Options);
-            return apiResponse;
-        };
-        /**
-         * Get a presigned post URL so we can upload directly to S3 via frontend.
-         */
-        this.presignedPost = async (props) => {
-            await this.ensureInit();
-            return new Promise(async (resolve, reject) => {
-                let response = null;
-                const formData = new FormData();
-                Object.entries({ fields: props.fields, file: props.file })
-                    .forEach(([key, value]) => {
-                    formData.append(key, value);
-                });
-                const upload = await fetch(props.url, {
-                    method: "POST",
-                    body: formData,
-                });
-                // Uploaded to S3
-                if (upload.ok) {
-                    response = `https://${props.bucket}.s3.${this.config.region}.amazonaws.com/${props.key}`;
-                    resolve(response);
-                }
-                // Failed to upload to S3
-                else {
-                    response = null;
-                    reject(response);
-                }
-            });
-        };
-        /**
-         * Download a file and write to S3.
-         */
-        this.urlContents = async (bucket, key, url) => {
-            await this.ensureInit();
-            return (0, axios_1.default)(url, {
-                responseType: "arraybuffer",
-                responseEncoding: "binary",
-            })
-                .then(async (response) => {
-                await this.writeFile(bucket, response.data, key, {
-                    ContentType: response.headers["content-type"],
-                    ContentLength: response.headers["content-length"],
-                });
+        });
+    };
+    /**
+     * Download a file and write to S3.
+     */
+    urlContents = async (bucket, key, url) => {
+        await this.ensureInit();
+        return get(url, {
+            responseType: "arraybuffer",
+            responseEncoding: "binary",
+        })
+            .then(async (response) => {
+            await this.writeFile(bucket, response.data, key, {
+                ContentType: response.headers["content-type"],
+                ContentLength: response.headers["content-length"],
             });
-        };
-    }
+        });
+    };
 }
-exports.AwsS3Namespace = AwsS3Namespace;