@8ms/helpers 1.39.0 → 1.40.1

package/dist/aws/s3/listFilesIteratively.mjs

@@ -0,0 +1,40 @@
+import listFiles from "./listFiles.mjs";
+import listFolders from "./listFolders.mjs";
+//#region src/aws/s3/listFilesIteratively.ts
+/**
+* Sub function
+*/
+const iterateFolders = async (props) => {
+	let response = [];
+	const folders = await listFolders({
+		bucket: props.bucket,
+		folder: props.folder
+	});
+	for (let i = 0; i < folders.length; i++) {
+		const subFolderFiles = await iterateFolders({
+			bucket: props.bucket,
+			folder: `${props.folder}/${folders[i]}`
+		});
+		const files = await listFiles({
+			bucket: props.bucket,
+			folder: `${props.folder}/${folders[i]}`
+		});
+		response = [
+			...response,
+			...files,
+			...subFolderFiles
+		];
+	}
+	return response;
+};
+/**
+* Fetch all the files within a given directory recursively
+*/
+const listFilesIteratively = async (props) => {
+	return await iterateFolders({
+		bucket: props.bucket,
+		folder: props.folder
+	});
+};
+//#endregion
+export { listFilesIteratively as default };

package/dist/aws/s3/listFolders.d.mts

@@ -0,0 +1,14 @@
+//#region src/aws/s3/listFolders.d.ts
+type ListFolders = {
+  bucket: string;
+  folder: string;
+};
+/**
+ * List the files in the given bucket and option folder.
+ */
+declare const listFolders: ({
+  bucket,
+  folder
+}: ListFolders) => Promise<string[]>;
+//#endregion
+export { listFolders as default };

package/dist/aws/s3/listFolders.mjs

@@ -0,0 +1,23 @@
+import { t as __require } from "../../chunk-y_GBKt04.mjs";
+import getFolder from "../../string/getFolder.mjs";
+//#region src/aws/s3/listFolders.ts
+/**
+* List the files in the given bucket and option folder.
+*/
+const listFolders = async ({ bucket, folder }) => {
+	const cleanFolder = getFolder({ input: folder });
+	let response = [];
+	const { ListObjectsV2Command } = __require("@aws-sdk/client-s3");
+	const apiResponse = await global.awsS3Client.send(new ListObjectsV2Command({
+		Bucket: bucket,
+		Delimiter: "/",
+		Prefix: "" === cleanFolder ? "" : cleanFolder + "/"
+	}));
+	if (void 0 !== apiResponse["CommonPrefixes"]) response = apiResponse["CommonPrefixes"].map((prefix) => {
+		const fileFolders = prefix.Prefix.slice(0, -1).split("/");
+		return fileFolders[fileFolders.length - 1];
+	});
+	return response;
+};
+//#endregion
+export { listFolders as default };

package/dist/aws/s3/moveFile.d.mts

@@ -0,0 +1,16 @@
+import { File } from "./copyFile.mjs";
+
+//#region src/aws/s3/moveFile.d.ts
+type MoveFiles = {
+  from: File;
+  to: File;
+};
+/**
+ * It's not possible to just move or rename a file, you must copy then delete the old file.
+ */
+declare const moveFile: ({
+  from,
+  to
+}: MoveFiles) => Promise<void>;
+//#endregion
+export { moveFile as default };

package/dist/aws/s3/moveFile.mjs

@@ -0,0 +1,18 @@
+import copyFile from "./copyFile.mjs";
+import deleteFile from "./deleteFile.mjs";
+//#region src/aws/s3/moveFile.ts
+/**
+* It's not possible to just move or rename a file, you must copy then delete the old file.
+*/
+const moveFile = async ({ from, to }) => {
+	await copyFile({
+		from,
+		to
+	});
+	await deleteFile({
+		bucket: from.bucket,
+		key: from.key
+	});
+};
+//#endregion
+export { moveFile as default };

package/dist/aws/s3/readBrotli.d.mts

@@ -0,0 +1,18 @@
+import { ReadFileResponse } from "./readFile.mjs";
+
+//#region src/aws/s3/readBrotli.d.ts
+type ReadBrotli = {
+  bucket: string;
+  key: string;
+  isJson?: boolean;
+};
+/**
+ * Read a file from S3 and return either null, the content or JSON decoded.
+ */
+declare const readBrotli: ({
+  bucket,
+  key,
+  isJson
+}: ReadBrotli) => Promise<ReadFileResponse>;
+//#endregion
+export { readBrotli as default };

package/dist/aws/s3/readBrotli.mjs

@@ -0,0 +1,20 @@
+import getBrotliDecompressed from "../../util/getBrotliDecompressed.mjs";
+import readFile from "./readFile.mjs";
+//#region src/aws/s3/readBrotli.ts
+/**
+* Read a file from S3 and return either null, the content or JSON decoded.
+*/
+const readBrotli = async ({ bucket, key, isJson }) => {
+	let response = await readFile({
+		bucket,
+		key,
+		isJson: false
+	});
+	if (void 0 !== response.body) {
+		response.body = await getBrotliDecompressed({ input: response.body });
+		if (false !== isJson) response.body = JSON.parse(response.body);
+	}
+	return response;
+};
+//#endregion
+export { readBrotli as default };

package/dist/aws/s3/readBuffer.d.mts

@@ -0,0 +1,19 @@
+import { Modified } from "./readFile.mjs";
+
+//#region src/aws/s3/readBuffer.d.ts
+type ReadBufferResponse = Modified & {
+  buffer: any;
+};
+type ReadBuffer = {
+  bucket: string;
+  key: string;
+};
+/**
+ * Similar function to reading the S3 file, but instead of a text file return a buffer.
+ */
+declare const readBuffer: ({
+  bucket,
+  key
+}: ReadBuffer) => Promise<ReadBufferResponse>;
+//#endregion
+export { ReadBufferResponse, readBuffer as default };

package/dist/aws/s3/readBuffer.mjs

@@ -0,0 +1,29 @@
+import { t as __require } from "../../chunk-y_GBKt04.mjs";
+import isResponse200 from "../isResponse200.mjs";
+import { readFileDefault } from "./readFile.mjs";
+//#region src/aws/s3/readBuffer.ts
+/**
+* Similar function to reading the S3 file, but instead of a text file return a buffer.
+*/
+const readBuffer = async ({ bucket, key }) => {
+	let response = {
+		...readFileDefault,
+		buffer: void 0
+	};
+	const { GetObjectCommand } = __require("@aws-sdk/client-s3");
+	const apiResponse = await global.awsS3Client.send(new GetObjectCommand({
+		Bucket: bucket,
+		Key: key
+	}));
+	if (isResponse200({ apiResponse })) {
+		const chunks = [];
+		response.buffer = await new Promise((resolve, reject) => {
+			apiResponse.Body.on("data", (chunk) => chunks.push(chunk));
+			apiResponse.Body.on("error", (err) => reject(err));
+			apiResponse.Body.on("end", () => resolve(Buffer.concat(chunks)));
+		});
+	} else throw new Error("Error reading file.");
+	return response;
+};
+//#endregion
+export { readBuffer as default };

package/dist/aws/s3/readFile.d.mts

@@ -0,0 +1,38 @@
+import { r as DurationComparison } from "../../index-CiGy7MyK.mjs";
+
+//#region src/aws/s3/readFile.d.ts
+type Modified = {
+  now: number;
+  modified: {
+    unix: null | number;
+    [DurationComparison.VS_NOW]: {
+      months: number;
+      days: number;
+      hours: number;
+      minutes: number;
+    };
+    [DurationComparison.VS_MIDNIGHT]: {
+      hours: number;
+      minutes: number;
+    };
+  };
+};
+type ReadFileResponse = Modified & {
+  body: any;
+};
+declare const readFileDefault: ReadFileResponse;
+type ReadFile = {
+  bucket: string;
+  key: string;
+  isJson?: boolean;
+};
+/**
+ * Read a file from S3 and return either null, the content or JSON decoded.
+ */
+declare const readFile: ({
+  bucket,
+  key,
+  isJson
+}: ReadFile) => Promise<ReadFileResponse>;
+//#endregion
+export { Modified, ReadFileResponse, readFile as default, readFileDefault };

package/dist/aws/s3/readFile.mjs

@@ -0,0 +1,64 @@
+import { t as __require } from "../../chunk-y_GBKt04.mjs";
+import isResponse200 from "../isResponse200.mjs";
+import getDate from "../../date/getDate.mjs";
+import getToday from "../../date/getToday.mjs";
+import { DurationComparison } from "../../date/index.mjs";
+import getStringFromStream from "../../string/getStringFromStream.mjs";
+import isFileExists from "./isFileExists.mjs";
+import { differenceInDays, differenceInHours, differenceInMinutes, differenceInMonths, getHours, getMinutes, getUnixTime } from "date-fns";
+import cloneDeep from "lodash/cloneDeep.js";
+//#region src/aws/s3/readFile.ts
+const readFileDefault = {
+	body: void 0,
+	now: void 0,
+	modified: {
+		unix: null,
+		[DurationComparison.VS_NOW]: {
+			months: 0,
+			days: 0,
+			hours: 0,
+			minutes: 0
+		},
+		[DurationComparison.VS_MIDNIGHT]: {
+			hours: 0,
+			minutes: 0
+		}
+	}
+};
+/**
+* Read a file from S3 and return either null, the content or JSON decoded.
+*/
+const readFile = async ({ bucket, key, isJson }) => {
+	let response = cloneDeep(readFileDefault);
+	const today = getToday({ setMidnight: false });
+	response.now = getUnixTime(today);
+	if (await isFileExists({
+		bucket,
+		key
+	})) {
+		const { GetObjectCommand } = __require("@aws-sdk/client-s3");
+		const apiResponse = await global.awsS3Client.send(new GetObjectCommand({
+			Bucket: bucket,
+			Key: key
+		}));
+		if (isResponse200({ apiResponse })) {
+			let now = today;
+			let modified = getDate({
+				input: apiResponse.LastModified,
+				setMidnight: false
+			});
+			response.modified.unix = getUnixTime(modified);
+			response.modified[DurationComparison.VS_NOW].months = differenceInMonths(now, modified);
+			response.modified[DurationComparison.VS_NOW].days = differenceInDays(now, modified);
+			response.modified[DurationComparison.VS_NOW].hours = differenceInHours(now, modified);
+			response.modified[DurationComparison.VS_NOW].minutes = differenceInMinutes(now, modified);
+			response.modified[DurationComparison.VS_MIDNIGHT].hours = getHours(now);
+			response.modified[DurationComparison.VS_MIDNIGHT].minutes = getMinutes(now);
+			response.body = await getStringFromStream({ stream: apiResponse.Body });
+			if (false !== isJson) response.body = JSON.parse(response.body) || void 0;
+		}
+	}
+	return response;
+};
+//#endregion
+export { readFile as default, readFileDefault };

package/dist/aws/s3/readGzip.d.mts

@@ -0,0 +1,18 @@
+import { ReadFileResponse } from "./readFile.mjs";
+
+//#region src/aws/s3/readGzip.d.ts
+type ReadBrotli = {
+  bucket: string;
+  key: string;
+  isJson?: boolean;
+};
+/**
+ * Read a file from S3 and return either null, the content or JSON decoded.
+ */
+declare const readGzip: ({
+  bucket,
+  key,
+  isJson
+}: ReadBrotli) => Promise<ReadFileResponse>;
+//#endregion
+export { readGzip as default };

package/dist/aws/s3/readGzip.mjs

@@ -0,0 +1,20 @@
+import getGzipDecompressed from "../../util/getGzipDecompressed.mjs";
+import readFile from "./readFile.mjs";
+//#region src/aws/s3/readGzip.ts
+/**
+* Read a file from S3 and return either null, the content or JSON decoded.
+*/
+const readGzip = async ({ bucket, key, isJson }) => {
+	let response = await readFile({
+		bucket,
+		key,
+		isJson: false
+	});
+	if (void 0 !== response.body) {
+		response.body = await getGzipDecompressed({ input: response.body });
+		if (false !== isJson) response.body = JSON.parse(response.body);
+	}
+	return response;
+};
+//#endregion
+export { readGzip as default };

package/dist/aws/s3/writeBrotli.d.mts

@@ -0,0 +1,20 @@
+//#region src/aws/s3/writeBrotli.d.ts
+type WriteBrotli = {
+  bucket: string;
+  data: any;
+  key: string;
+  isJson?: boolean;
+  [options: string]: any;
+};
+/**
+ * Write a brotli file to S3.
+ */
+declare const writeBrotli: ({
+  bucket,
+  data,
+  key,
+  isJson,
+  ...options
+}: WriteBrotli) => Promise<any>;
+//#endregion
+export { writeBrotli as default };

package/dist/aws/s3/writeBrotli.mjs

@@ -0,0 +1,18 @@
+import getBrotliCompressed from "../../util/getBrotliCompressed.mjs";
+import writeFile from "./writeFile.mjs";
+//#region src/aws/s3/writeBrotli.ts
+/**
+* Write a brotli file to S3.
+*/
+const writeBrotli = async ({ bucket, data, key, isJson, ...options }) => {
+	let finalData = data;
+	if (false !== isJson) finalData = JSON.stringify(data);
+	return await writeFile({
+		bucket,
+		data: await getBrotliCompressed({ input: finalData }),
+		key,
+		...options
+	});
+};
+//#endregion
+export { writeBrotli as default };

package/dist/aws/s3/writeFile.d.mts

@@ -0,0 +1,18 @@
+//#region src/aws/s3/writeFile.d.ts
+type WriteFile = {
+  bucket: string;
+  data: any;
+  key: string;
+  [options: string]: any;
+};
+/**
+ * Write a file to S3.
+ */
+declare const writeFile: ({
+  bucket,
+  data,
+  key,
+  ...options
+}: WriteFile) => Promise<any>;
+//#endregion
+export { writeFile as default };

package/dist/aws/s3/writeFile.mjs

@@ -0,0 +1,16 @@
+import { t as __require } from "../../chunk-y_GBKt04.mjs";
+//#region src/aws/s3/writeFile.ts
+/**
+* Write a file to S3.
+*/
+const writeFile = async ({ bucket, data, key, ...options }) => {
+	const { PutObjectCommand } = __require("@aws-sdk/client-s3");
+	return await global.awsS3Client.send(new PutObjectCommand({
+		Bucket: bucket,
+		Body: data,
+		Key: key,
+		...options
+	}));
+};
+//#endregion
+export { writeFile as default };

package/dist/aws/s3/writeGzip.d.mts

@@ -0,0 +1,20 @@
+//#region src/aws/s3/writeGzip.d.ts
+type WriteGzip = {
+  bucket: string;
+  data: any;
+  key: string;
+  isJson?: boolean;
+  [options: string]: any;
+};
+/**
+ * Write a gzip file to S3.
+ */
+declare const writeGzip: ({
+  bucket,
+  data,
+  key,
+  isJson,
+  ...options
+}: WriteGzip) => Promise<any>;
+//#endregion
+export { writeGzip as default };

package/dist/aws/s3/writeGzip.mjs

@@ -0,0 +1,18 @@
+import getGzipCompressed from "../../util/getGzipCompressed.mjs";
+import writeFile from "./writeFile.mjs";
+//#region src/aws/s3/writeGzip.ts
+/**
+* Write a gzip file to S3.
+*/
+const writeGzip = async ({ bucket, data, key, isJson, ...options }) => {
+	let finalData = data;
+	if (false !== isJson) finalData = JSON.stringify(data);
+	return await writeFile({
+		bucket,
+		data: await getGzipCompressed({ input: finalData }),
+		key,
+		...options
+	});
+};
+//#endregion
+export { writeGzip as default };

package/dist/aws/s3/writePresignedPost.d.mts

@@ -0,0 +1,24 @@
+import { Config } from "../getConfig.mjs";
+
+//#region src/aws/s3/writePresignedPost.d.ts
+type WritePresignedPost = {
+  bucket: string;
+  config: Config;
+  fields: any;
+  file: any;
+  key: string;
+  url: string;
+};
+/**
+ * Get a presigned post URL so we can upload directly to S3 via frontend.
+ */
+declare const writePresignedPost: ({
+  bucket,
+  config,
+  fields,
+  file,
+  key,
+  url
+}: WritePresignedPost) => Promise<null | string>;
+//#endregion
+export { writePresignedPost as default };

package/dist/aws/s3/writePresignedPost.mjs

@@ -0,0 +1,28 @@
+//#region src/aws/s3/writePresignedPost.ts
+/**
+* Get a presigned post URL so we can upload directly to S3 via frontend.
+*/
+const writePresignedPost = async ({ bucket, config, fields, file, key, url }) => {
+	return new Promise(async (resolve, reject) => {
+		let response;
+		const formData = new FormData();
+		Object.entries({
+			fields,
+			file
+		}).forEach(([key, value]) => {
+			formData.append(key, value);
+		});
+		if ((await fetch(url, {
+			method: "POST",
+			body: formData
+		})).ok) {
+			response = `https://${bucket}.s3.${config.region}.amazonaws.com/${key}`;
+			resolve(response);
+		} else {
+			response = null;
+			reject(response);
+		}
+	});
+};
+//#endregion
+export { writePresignedPost as default };

package/dist/aws/s3/writeUrlContents.d.mts

@@ -0,0 +1,16 @@
+//#region src/aws/s3/writeUrlContents.d.ts
+type WriteUrlContents = {
+  bucket: string;
+  key: string;
+  url: string;
+};
+/**
+ * Download a file and write to S3.
+ */
+declare const writeUrlContents: ({
+  bucket,
+  key,
+  url
+}: WriteUrlContents) => Promise<void>;
+//#endregion
+export { writeUrlContents as default };

package/dist/aws/s3/writeUrlContents.mjs

@@ -0,0 +1,19 @@
+import writeFile from "./writeFile.mjs";
+import ky from "ky";
+//#region src/aws/s3/writeUrlContents.ts
+/**
+* Download a file and write to S3.
+*/
+const writeUrlContents = async ({ bucket, key, url }) => {
+	const response = await ky.get(url);
+	const arrayBuffer = await response.arrayBuffer();
+	await writeFile({
+		bucket,
+		data: Buffer.from(arrayBuffer),
+		key,
+		ContentType: response.headers.get("content-type"),
+		ContentLength: response.headers.get("content-length")
+	});
+};
+//#endregion
+export { writeUrlContents as default };

package/dist/aws/s3cache/getCache.d.mts

@@ -0,0 +1,19 @@
+import { Cache } from "./index.mjs";
+import { GetKey } from "./getKey.mjs";
+
+//#region src/aws/s3cache/getCache.d.ts
+type GetCache = GetKey & {
+  bucket: string;
+  cache: Cache;
+};
+/**
+ * Get the stored cache if it exists.
+ */
+declare const getCache: ({
+  bucket,
+  cache,
+  fileName,
+  folder
+}: GetCache) => Promise<any>;
+//#endregion
+export { getCache as default };

package/dist/aws/s3cache/getCache.mjs

@@ -0,0 +1,25 @@
+import { Interval } from "../../date/index.mjs";
+import readGzip from "../s3/readGzip.mjs";
+import getKey from "./getKey.mjs";
+//#region src/aws/s3cache/getCache.ts
+/**
+* Get the stored cache if it exists.
+*/
+const getCache = async ({ bucket, cache, fileName, folder }) => {
+	let response = void 0;
+	const s3CacheKey = getKey({
+		fileName,
+		folder
+	});
+	if (cache) try {
+		const cached = await readGzip({
+			bucket,
+			key: s3CacheKey,
+			isJson: true
+		});
+		if (void 0 !== cached.body && (Interval.FOREVER === cache.timeframe || cached.modified[cache.from][cache.timeframe] < cache.duration)) response = cached.body;
+	} catch (error) {}
+	return response;
+};
+//#endregion
+export { getCache as default };

package/dist/aws/s3cache/getKey.d.mts

@@ -0,0 +1,15 @@
+//#region src/aws/s3cache/getKey.d.ts
+type GetKey = {
+  fileName: any;
+  folder: string;
+};
+/**
+ * Take an input and return the key.
+ * Always in the "_cache" folder with the "environment" followed by the optional folder then the key.
+ */
+declare const getKey: ({
+  fileName,
+  folder
+}: GetKey) => string;
+//#endregion
+export { GetKey, getKey as default };

package/dist/aws/s3cache/getKey.mjs

@@ -0,0 +1,15 @@
+import getSha256 from "../../crypto/getSha256.mjs";
+import getEnvironment from "../../environment/getEnvironment.mjs";
+import trimStart from "lodash/trimStart.js";
+//#region src/aws/s3cache/getKey.ts
+/**
+* Take an input and return the key.
+* Always in the "_cache" folder with the "environment" followed by the optional folder then the key.
+*/
+const getKey = ({ fileName, folder }) => {
+	const fileNameString = getSha256({ input: fileName });
+	const folderPath = trimStart("" === folder ? "" : `${folder}/`, "/");
+	return `cache/${getEnvironment()}/${folderPath}${fileNameString}.json.gz`;
+};
+//#endregion
+export { getKey as default };

package/dist/aws/s3cache/index.d.mts

@@ -0,0 +1,10 @@
+import { o as Interval, r as DurationComparison } from "../../index-CiGy7MyK.mjs";
+
+//#region src/aws/s3cache/index.d.ts
+type Cache = {
+  duration: number;
+  from: DurationComparison;
+  timeframe: Interval;
+};
+//#endregion
+export { Cache };

package/dist/aws/s3cache/saveCache.d.mts

@@ -0,0 +1,16 @@
+//#region src/aws/s3cache/saveCache.d.ts
+type SaveCache = {
+  bucket: string;
+  data: any;
+  key: string;
+};
+/**
+ * Save the cache.
+ */
+declare const saveCache: ({
+  bucket,
+  data,
+  key
+}: SaveCache) => Promise<any>;
+//#endregion
+export { saveCache as default };