@8ms/helpers 1.39.0 → 2.0.1

package/aws/isResponse200.js

@@ -1,22 +1,16 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const defaultTo_1 = __importDefault(require("../util/defaultTo"));
+exports.isResponse200 = void 0;
+const util_1 = require("../util");
 /**
  * Was the API response a 200?
  */
-const isResponse200 = ({ apiResponse }) => {
+const isResponse200 = (apiResponse) => {
     let response = false;
-    const responseCode = (0, defaultTo_1.default)({
-        defaultValue: 0,
-        instance: apiResponse,
-        keys: ['$metadata', 'httpStatusCode'],
-    });
+    const responseCode = (0, util_1.defaultTo)(apiResponse, ["$metadata", "httpStatusCode"], 0);
     if (200 === responseCode) {
         response = true;
     }
     return response;
 };
-exports.default = isResponse200;
+exports.isResponse200 = isResponse200;

package/aws/lambda/AwsLambdaNamespace.d.ts

@@ -0,0 +1,21 @@
+import { BaseNamespace } from "../../_class";
+import { AwsConfig } from "../index";
+import type { LambdaClient } from "@aws-sdk/client-lambda";
+type InvokeProps = {
+    awaitResponse?: boolean;
+    functionName: string;
+    isJson?: boolean;
+    payload?: object;
+};
+export declare class AwsLambdaNamespace extends BaseNamespace {
+    client: LambdaClient | null;
+    config: AwsConfig;
+    ensureInit: () => Promise<void>;
+    /**
+     * Invoke a AWS Lambda function by passing in the Function name and optional Payload data.
+     * Runs asynchronously, doesn't wait for function to fully end.
+     * Library: @aws-sdk/client-lambda
+     */
+    invoke: (props: InvokeProps) => Promise<any>;
+}
+export {};

package/aws/lambda/AwsLambdaNamespace.js

@@ -0,0 +1,110 @@
+"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);
+    };
+    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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsLambdaNamespace = void 0;
+const _class_1 = require("../../_class");
+const __1 = require("../");
+const api_1 = require("../../api");
+class AwsLambdaNamespace extends _class_1.BaseNamespace {
+    constructor() {
+        super(...arguments);
+        this.client = null;
+        this.ensureInit = async () => {
+            if (!this.client) {
+                try {
+                    const { LambdaClient } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-lambda")));
+                    this.client = new LambdaClient(this.config);
+                }
+                catch (e) {
+                    throw new Error("AWS Lambda Client not installed");
+                }
+            }
+        };
+        /**
+         * Invoke a AWS Lambda function by passing in the Function name and optional Payload data.
+         * Runs asynchronously, doesn't wait for function to fully end.
+         * Library: @aws-sdk/client-lambda
+         */
+        this.invoke = async (props) => {
+            await this.ensureInit();
+            const { InvokeCommand } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-lambda")));
+            let response = false;
+            const params = {
+                FunctionName: props.functionName,
+                InvocationType: true === props.awaitResponse ? "RequestResponse" : "Event",
+            };
+            // Payload is defined add to parameters
+            if (undefined !== props.payload) {
+                params["Payload"] = new Uint8Array(Buffer.from(JSON.stringify(props.payload)));
+            }
+            // Create the Lambda Command
+            // @ts-ignore
+            const command = new InvokeCommand(params);
+            // Fire the event but don't wait for it to complete
+            const apiResponse = await this.client.send(command);
+            // Success
+            if ((0, __1.isResponse200)(apiResponse)) {
+                // Return the data
+                if (props.awaitResponse && undefined !== apiResponse.Payload) {
+                    const asciiDecoder = new TextDecoder("ascii");
+                    response = asciiDecoder.decode(apiResponse.Payload);
+                    // Decode string as JSON object
+                    if (true === props.isJson) {
+                        response = JSON.parse(response);
+                        // If it's still a string, double decode it
+                        if ("string" === typeof response) {
+                            response = JSON.parse(response);
+                        }
+                        // If the response is a ApiResponse compatible
+                        if (undefined !== response &&
+                            // @ts-ignore
+                            undefined !== response?.error &&
+                            // @ts-ignore
+                            undefined !== response?.state) {
+                            // @ts-ignore
+                            response = (new api_1.ApiResponseClass()).fromJson(response);
+                        }
+                    }
+                }
+                // Success but not waiting for response
+                else {
+                    response = true;
+                }
+            }
+            return response;
+        };
+    }
+}
+exports.AwsLambdaNamespace = AwsLambdaNamespace;

package/aws/lambda/index.d.ts

@@ -0,0 +1,4 @@
+import { AwsLambdaNamespace } from "./AwsLambdaNamespace";
+import { AwsConfig } from "../index";
+export declare const awsLambdaClient: (key?: string, config?: AwsConfig, vaultId?: string, itemId?: string) => Promise<AwsLambdaNamespace>;
+export declare const getHandlerPath: (input: string) => string;

package/aws/lambda/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHandlerPath = exports.awsLambdaClient = void 0;
+const AwsLambdaNamespace_1 = require("./AwsLambdaNamespace");
+const index_1 = require("../index");
+const awsLambdaNamespaces = new Map();
+const awsLambdaClient = async (key = "default", config, vaultId, itemId) => {
+    if (awsLambdaNamespaces.has(key)) {
+        return awsLambdaNamespaces.get(key);
+    }
+    const instanceConfig = await (0, index_1.getConfig)(key, config, vaultId, itemId);
+    const namespace = new AwsLambdaNamespace_1.AwsLambdaNamespace(key, instanceConfig);
+    awsLambdaNamespaces.set(key, namespace);
+    return namespace;
+};
+exports.awsLambdaClient = awsLambdaClient;
+const getHandlerPath = (input) => {
+    return `${input.split(process.cwd())[1].substring(1)
+        .replace(/\\/g, "/")}`;
+};
+exports.getHandlerPath = getHandlerPath;

package/aws/s3/AwsS3Namespace.d.ts

@@ -0,0 +1,60 @@
+import { BaseNamespace } from "../../_class";
+import { AwsConfig } from "../index";
+import type { S3Client } from "@aws-sdk/client-s3";
+import { Modified, ReadFileResponse } from "./index";
+export type ReadBufferResponse = Modified & {
+    buffer: any;
+};
+type Options = {
+    [key: string]: any;
+};
+type WritePresignedPostProps = {
+    bucket: string;
+    fields: any;
+    file: any;
+    key: string;
+    url: string;
+};
+export declare class AwsS3Namespace extends BaseNamespace {
+    client: S3Client | null;
+    config: AwsConfig;
+    ensureInit: () => Promise<void>;
+    copy: (fromBucket: string, fromKey: string, toBucket: string, toKey: string) => Promise<void>;
+    deleteFile: (bucket: string, key: string) => Promise<void>;
+    deleteFiles: (bucket: string, keys: string[]) => Promise<void>;
+    deleteFolder: (bucket: string, folder: string) => Promise<void>;
+    /**
+     * List the files in the given bucket and option folder
+     */
+    listFiles: (bucket: string, folder?: string) => Promise<string[]>;
+    /**
+     * Fetch all the files within a given directory recursively
+     */
+    filesIteratively: (bucket: string, folder: string) => Promise<string[]>;
+    /**
+     * Sub function
+     */
+    private iterateFolders;
+    /**
+     * List the files in the given bucket and option folder.
+     */
+    listFolders: (bucket: string, folder: string) => Promise<string[]>;
+    move: (fromBucket: string, fromKey: string, toBucket: string, toKey: string) => Promise<void>;
+    readBrotli: (bucket: string, key: string, isJson?: boolean) => Promise<ReadFileResponse>;
+    readBuffer: (bucket: string, key: string) => Promise<ReadBufferResponse>;
+    fileExists: (bucket: string, key: string) => Promise<boolean>;
+    readFile: (bucket: string, key: string, isJson?: boolean) => Promise<ReadFileResponse>;
+    readGzip: (bucket: string, key: string, isJson?: boolean) => Promise<ReadFileResponse>;
+    writeBrotli: (bucket: string, key: string, data: any, isJson?: boolean, options?: Options) => Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
+    writeFile: (bucket: string, key: string, data: any, options?: Options) => Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
+    writeGzip: (bucket: string, key: string, data: any, isJson?: boolean, options?: Options) => Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
+    /**
+     * Get a presigned post URL so we can upload directly to S3 via frontend.
+     */
+    presignedPost: (props: WritePresignedPostProps) => Promise<null | string>;
+    /**
+     * Download a file and write to S3.
+     */
+    urlContents: (bucket: string, key: string, url: string) => Promise<void>;
+}
+export {};

package/aws/s3/AwsS3Namespace.js

@@ -0,0 +1,401 @@
+"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);
+    };
+    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;
+    };
+})();
+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 index_1 = require("../index");
+const string_1 = require("../../string");
+const util_1 = require("../../util");
+const index_2 = require("./index");
+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.client = null;
+        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");
+                }
+            }
+        };
+        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({
+                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, isJson = true) => {
+            await this.ensureInit();
+            let response = await this.readFile(bucket, key, isJson);
+            // Cache exists and is still within our caching timeframe
+            if (undefined !== response.body) {
+                response.body = await (0, util_1.getBrotliDecompressed)(response.body);
+                if (false !== isJson) {
+                    response.body = JSON.parse(response.body);
+                }
+            }
+            return response;
+        };
+        this.readBuffer = async (bucket, key) => {
+            await this.ensureInit();
+            const { GetObjectCommand } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-s3")));
+            let response = {
+                ...index_2.readFileDefault,
+                buffer: undefined,
+            };
+            const apiResponse = await this.client.send(new GetObjectCommand({
+                Bucket: bucket,
+                Key: key,
+            }));
+            if ((0, index_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, index_1.isResponse200)(apiResponse);
+            }
+            catch (exception) {
+                response = false;
+            }
+            return response;
+        };
+        this.readFile = async (bucket, key, isJson = true) => {
+            await this.ensureInit();
+            let response = (0, cloneDeep_1.default)(index_2.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,
+                }));
+                //console.log('apiResponse', apiResponse);
+                if ((0, index_1.isResponse200)(apiResponse)) {
+                    let modified = (0, date_1.getDate)(apiResponse.LastModified);
+                    // Convert the date to unix
+                    response.modified.unix = modified.toUnixInteger();
+                    // Compare now to unix
+                    response.modified.vs_now.months = today.diff(modified, 'months').months;
+                    response.modified.vs_now.days = today.diff(modified, 'days').days;
+                    response.modified.vs_now.hours = today.diff(modified, 'hours').hours;
+                    response.modified.vs_now.minutes = today.diff(modified, 'minutes').minutes;
+                    // Compare now to midnight
+                    response.modified.vs_midnight.hours = today.diff(midnight, 'hours').hours;
+                    response.modified.vs_midnight.minutes = today.diff(midnight, 'minutes').hours;
+                    // Convert stream into a string
+                    response.body = await (0, string_1.getStringFromStream)(apiResponse.Body);
+                    // If we need to return JSON, parse it. On error return undefined
+                    if (false !== isJson) {
+                        response.body = JSON.parse(response.body) || null;
+                    }
+                }
+            }
+            catch (error) {
+                response.body = null;
+                response.error = error;
+            }
+            return response;
+        };
+        this.readGzip = async (bucket, key, isJson = true) => {
+            await this.ensureInit();
+            let response = await this.readFile(bucket, key, isJson);
+            // Cache exists and is still within our caching timeframe
+            if (undefined !== response.body) {
+                response.body = await (0, util_1.getGzipDecompressed)(response.body);
+                if (false !== isJson) {
+                    response.body = JSON.parse(response.body);
+                }
+            }
+            return response;
+        };
+        this.writeBrotli = async (bucket, key, data, isJson = true, options = {}) => {
+            await this.ensureInit();
+            let finalData = data;
+            if (false !== isJson) {
+                finalData = JSON.stringify(data);
+            }
+            // Compress the data
+            const brotliData = await (0, util_1.getBrotliCompressed)({
+                input: finalData,
+            });
+            const apiResponse = await this.writeFile(bucket, key, brotliData, options);
+            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.writeGzip = async (bucket, key, data, isJson = true, options = {}) => {
+            await this.ensureInit();
+            let finalData = data;
+            if (false !== isJson) {
+                finalData = JSON.stringify(data);
+            }
+            // Compress the data
+            const gzipData = await (0, util_1.getGzipCompressed)(finalData);
+            const apiResponse = await this.writeFile(bucket, key, gzipData, options);
+            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"],
+                });
+            });
+        };
+    }
+}
+exports.AwsS3Namespace = AwsS3Namespace;

package/aws/s3/index.d.ts

@@ -0,0 +1,25 @@
+import { AwsS3Namespace } from "./AwsS3Namespace";
+import { AwsConfig } from "../index";
+export declare const awsS3Client: (key?: string, config?: AwsConfig, vaultId?: string, itemId?: string) => Promise<AwsS3Namespace>;
+export type Modified = {
+    now: number;
+    modified: {
+        unix: null | number;
+        vs_now: {
+            months: number;
+            days: number;
+            hours: number;
+            minutes: number;
+        };
+        vs_midnight: {
+            hours: number;
+            minutes: number;
+        };
+    };
+};
+export type ReadFileResponse = Modified & {
+    body: any;
+    error: any;
+};
+export declare const readFileDefault: ReadFileResponse;
+export { payloadSchema, PayloadSchemaType } from "./payload";