@8ms/helpers 2.4.8 → 2.4.10

package/dist/aws/s3/server/AwsS3Namespace.cjs

@@ -0,0 +1,297 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require__class_BaseNamespace = require("../../../_class/BaseNamespace.cjs");
+const require_date_calculation = require("../../../date/calculation.cjs");
+const require_date_format = require("../../../date/format.cjs");
+require("../../../date/index.cjs");
+const require_string_getFolder = require("../../../string/getFolder.cjs");
+const require_string_getStringFromStream = require("../../../string/getStringFromStream.cjs");
+require("../../../string/index.cjs");
+const require_aws_server_isResponse200 = require("../../server/isResponse200.cjs");
+require("../../server/index.cjs");
+const require_util_server_getBrotliCompressed = require("../../../util/server/getBrotliCompressed.cjs");
+const require_util_server_getBrotliDecompressed = require("../../../util/server/getBrotliDecompressed.cjs");
+const require_util_server_getGzipCompressed = require("../../../util/server/getGzipCompressed.cjs");
+const require_util_server_getGzipDecompressed = require("../../../util/server/getGzipDecompressed.cjs");
+const require_aws_s3_server_awsS3 = require("./awsS3.cjs");
+require("./index.cjs");
+//#region src/aws/s3/server/AwsS3Namespace.ts
+var AwsS3Namespace = class extends require__class_BaseNamespace.BaseNamespace {
+	constructor(..._args) {
+		super(..._args);
+		this.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");
+			}
+		};
+		this.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
+			}));
+		};
+		this.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
+			}));
+		};
+		this.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 })) }
+			}));
+		};
+		this.deleteFolder = async (bucket, folder) => {
+			await this.ensureInit();
+			const { ListObjectsV2Command, DeleteObjectsCommand } = await import("@aws-sdk/client-s3");
+			const cleanFolder = require_string_getFolder.getFolder(folder);
+			const apiResponse = await this.client.send(new ListObjectsV2Command({
+				Bucket: bucket,
+				Prefix: "" === cleanFolder ? "" : cleanFolder + "/"
+			}));
+			if (!apiResponse.Contents?.length || 0 === apiResponse.Contents.length) return;
+			const keys = apiResponse.Contents.map((file) => ({ Key: file.Key }));
+			await this.client.send(new DeleteObjectsCommand({
+				Bucket: bucket,
+				Delete: { Objects: keys }
+			}));
+			if (apiResponse.IsTruncated) await this.deleteFolder(bucket, folder);
+		};
+		this.listFiles = async (bucket, folder = "") => {
+			await this.ensureInit();
+			const { ListObjectsV2Command } = await import("@aws-sdk/client-s3");
+			const cleanFolder = require_string_getFolder.getFolder(folder);
+			const apiResponse = await this.client.send(new ListObjectsV2Command({
+				Bucket: bucket,
+				Delimiter: "/",
+				Prefix: "" === cleanFolder ? "" : cleanFolder + "/"
+			}));
+			if (!apiResponse?.["Contents"]) return [];
+			const valid = apiResponse["Contents"].filter((content) => {
+				if (!content?.["Key"]) return false;
+				const keyExploded = content["Key"].split("/");
+				return keyExploded[keyExploded.length - 1].indexOf(".") > -1;
+			});
+			if (0 === valid.length) return [];
+			return valid.map((entry) => entry?.["Key"] ?? "").filter((entryKey) => "" !== entryKey);
+		};
+		this.filesIteratively = async (bucket, folder) => {
+			await this.ensureInit();
+			return await this.iterateFolders(bucket, folder);
+		};
+		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;
+		};
+		this.listFolders = async (bucket, folder) => {
+			await this.ensureInit();
+			const { ListObjectsV2Command } = await import("@aws-sdk/client-s3");
+			const cleanFolder = require_string_getFolder.getFolder(folder);
+			const apiResponse = await this.client.send(new ListObjectsV2Command({
+				Bucket: bucket,
+				Delimiter: "/",
+				Prefix: "" === cleanFolder ? "" : cleanFolder + "/"
+			}));
+			if (!apiResponse?.["CommonPrefixes"]) return [];
+			return apiResponse["CommonPrefixes"].map((prefix) => {
+				if (!prefix?.Prefix) return "";
+				const fileFolders = prefix.Prefix.slice(0, -1).split("/");
+				return fileFolders[fileFolders.length - 1];
+			}).filter((prefixFolder) => "" !== prefixFolder);
+		};
+		this.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
+			}));
+		};
+		this.readBrotli = async (bucket, key, brotliOptions = {}, awsS3Options = {}) => {
+			await this.ensureInit();
+			const apiResponse = await this.readFile(bucket, key, awsS3Options);
+			if (void 0 !== apiResponse.body) apiResponse.body = await require_util_server_getBrotliDecompressed.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 (void 0 !== apiResponse.body) {
+				apiResponse.body = await require_util_server_getBrotliDecompressed.getBrotliDecompressed(apiResponse.body, brotliOptions);
+				apiResponse.body = JSON.parse(apiResponse.body) || null;
+			}
+			return apiResponse;
+		};
+		this.readBuffer = async (bucket, key) => {
+			await this.ensureInit();
+			const { GetObjectCommand } = await import("@aws-sdk/client-s3");
+			let response = {
+				...require_aws_s3_server_awsS3.readFileDefault,
+				buffer: void 0
+			};
+			const apiResponse = await this.client.send(new GetObjectCommand({
+				Bucket: bucket,
+				Key: key
+			}));
+			if (require_aws_server_isResponse200.isResponse200(apiResponse)) {
+				const chunks = [];
+				response.buffer = await new Promise((resolve, reject) => {
+					const body = apiResponse.Body;
+					body.on("data", (chunk) => chunks.push(chunk));
+					body.on("error", (err) => reject(err));
+					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 import("@aws-sdk/client-s3");
+				response = require_aws_server_isResponse200.isResponse200(await this.client.send(new HeadObjectCommand({
+					Bucket: bucket,
+					Key: key
+				})));
+			} catch (exception) {
+				response = false;
+			}
+			return response;
+		};
+		this.readFile = async (bucket, key, options = {}) => {
+			await this.ensureInit();
+			let response = structuredClone(require_aws_s3_server_awsS3.readFileDefault);
+			const today = require_date_calculation.getToday();
+			require_date_calculation.getToday(true);
+			try {
+				response.now = today.toUnixInteger();
+				const { GetObjectCommand } = await import("@aws-sdk/client-s3");
+				const apiResponse = await this.client.send(new GetObjectCommand({
+					Bucket: bucket,
+					Key: key,
+					...options
+				}));
+				if (require_aws_server_isResponse200.isResponse200(apiResponse)) {
+					response.modified = require_date_format.getYmdHisString(apiResponse.LastModified);
+					response.body = await require_string_getStringFromStream.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);
+			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 (void 0 !== apiResponse.body) {
+				apiResponse.body = await require_util_server_getGzipDecompressed.getGzipDecompressed(apiResponse.body, gzipOptions);
+				apiResponse.body = JSON.parse(apiResponse.body) || null;
+			}
+			return apiResponse;
+		};
+		this.readGzip = async (bucket, key, gzipOptions = {}, awsS3Options = {}) => {
+			await this.ensureInit();
+			const apiResponse = await this.readFile(bucket, key, awsS3Options);
+			if (void 0 !== apiResponse.body) apiResponse.body = await require_util_server_getGzipDecompressed.getGzipDecompressed(apiResponse.body, gzipOptions);
+			return apiResponse;
+		};
+		this.writeBrotli = async (bucket, key, data, brotliOptions = {}, awsS3Options = {}) => {
+			await this.ensureInit();
+			let finalData = data;
+			finalData = await require_util_server_getBrotliCompressed.getBrotliCompressed(finalData, brotliOptions);
+			return await this.writeFile(bucket, key, finalData, awsS3Options);
+		};
+		this.writeFile = async (bucket, key, data, options = {}) => {
+			await this.ensureInit();
+			const { PutObjectCommand } = await import("@aws-sdk/client-s3");
+			return await this.client.send(new PutObjectCommand({
+				Bucket: bucket,
+				Body: data,
+				Key: key,
+				...options
+			}));
+		};
+		this.writeJson = async (bucket, key, data, options = {}) => {
+			await this.ensureInit();
+			return await this.writeFile(bucket, key, JSON.stringify(data), options);
+		};
+		this.writeJsonGzip = async (bucket, key, data, gzipOptions = {}, awsS3Options = {}) => {
+			await this.ensureInit();
+			let finalData = JSON.stringify(data);
+			finalData = await require_util_server_getGzipCompressed.getGzipCompressed(finalData, gzipOptions);
+			return await this.writeFile(bucket, key, finalData, awsS3Options);
+		};
+		this.writeGzip = async (bucket, key, data, gzipOptions = {}, awsS3Options = {}) => {
+			await this.ensureInit();
+			let finalData = data;
+			finalData = await require_util_server_getGzipCompressed.getGzipCompressed(finalData, gzipOptions);
+			return await this.writeFile(bucket, key, finalData, awsS3Options);
+		};
+		this.presignedPost = async (props) => {
+			await this.ensureInit();
+			return new Promise(async (resolve, reject) => {
+				let response = null;
+				const formData = new FormData();
+				Object.entries(props.fields).forEach(([key, value]) => {
+					formData.append(key, value);
+				});
+				formData.append("file", props.file);
+				if ((await fetch(props.url, {
+					method: "POST",
+					body: formData
+				})).ok) {
+					response = `https://${props.bucket}.s3.${this.config.region}.amazonaws.com/${props.key}`;
+					resolve(response);
+				} else {
+					response = null;
+					reject(response);
+				}
+			});
+		};
+		this.urlContents = async (bucket, key, url) => {
+			await this.ensureInit();
+			const { default: ky } = await import("ky");
+			const response = await ky.get(url);
+			const arrayBuffer = await response.arrayBuffer();
+			const data = Buffer.from(arrayBuffer);
+			await this.writeFile(bucket, key, data, {
+				ContentType: response.headers.get("content-type"),
+				ContentLength: response.headers.get("content-length")
+			});
+		};
+	}
+};
+//#endregion
+exports.AwsS3Namespace = AwsS3Namespace;

package/dist/aws/s3/server/AwsS3Namespace.d.cts

@@ -0,0 +1,69 @@
+import { BaseNamespace } from "../../../_class/BaseNamespace.cjs";
+import { AwsConfig } from "../../server/aws.cjs";
+import { Modified, ReadFileResponse } from "./awsS3.cjs";
+import * as _$_aws_sdk_client_s30 from "@aws-sdk/client-s3";
+import { S3Client } from "@aws-sdk/client-s3";
+
+//#region src/aws/s3/server/AwsS3Namespace.d.ts
+type ReadBufferResponse = Modified & {
+  buffer: any;
+};
+type Options = {
+  [key: string]: any;
+};
+type WritePresignedPostProps = {
+  bucket: string;
+  fields: Record<string, string>;
+  file: File | Blob;
+  key: string;
+  url: string;
+};
+declare class AwsS3Namespace extends BaseNamespace {
+  client: S3Client;
+  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, brotliOptions?: object, awsS3Options?: Options) => Promise<ReadFileResponse>;
+  readJsonBrotli: (bucket: string, key: string, brotliOptions?: object, awsS3Options?: Options) => Promise<ReadFileResponse>;
+  readBuffer: (bucket: string, key: string) => Promise<ReadBufferResponse>;
+  fileExists: (bucket: string, key: string) => Promise<boolean>;
+  readFile: (bucket: string, key: string, options?: Options) => Promise<ReadFileResponse>;
+  readJson: (bucket: string, key: string) => Promise<ReadFileResponse>;
+  readJsonGzip: (bucket: string, key: string, gzipOptions?: object, awsS3Options?: Options) => Promise<ReadFileResponse>;
+  readGzip: (bucket: string, key: string, gzipOptions?: object, awsS3Options?: Options) => Promise<ReadFileResponse>;
+  writeBrotli: (bucket: string, key: string, data: any, brotliOptions?: object, awsS3Options?: Options) => Promise<_$_aws_sdk_client_s30.PutObjectCommandOutput>;
+  writeFile: (bucket: string, key: string, data: any, options?: Options) => Promise<_$_aws_sdk_client_s30.PutObjectCommandOutput>;
+  writeJson: (bucket: string, key: string, data: any, options?: Options) => Promise<_$_aws_sdk_client_s30.PutObjectCommandOutput>;
+  writeJsonGzip: (bucket: string, key: string, data: any, gzipOptions?: object, awsS3Options?: Options) => Promise<_$_aws_sdk_client_s30.PutObjectCommandOutput>;
+  writeGzip: (bucket: string, key: string, data: any, gzipOptions?: object, awsS3Options?: Options) => Promise<_$_aws_sdk_client_s30.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>;
+}
+//#endregion
+export { AwsS3Namespace, ReadBufferResponse };

package/dist/aws/s3/server/AwsS3Namespace.d.mts

@@ -0,0 +1,69 @@
+import { BaseNamespace } from "../../../_class/BaseNamespace.mjs";
+import { AwsConfig } from "../../server/aws.mjs";
+import { Modified, ReadFileResponse } from "./awsS3.mjs";
+import * as _$_aws_sdk_client_s30 from "@aws-sdk/client-s3";
+import { S3Client } from "@aws-sdk/client-s3";
+
+//#region src/aws/s3/server/AwsS3Namespace.d.ts
+type ReadBufferResponse = Modified & {
+  buffer: any;
+};
+type Options = {
+  [key: string]: any;
+};
+type WritePresignedPostProps = {
+  bucket: string;
+  fields: Record<string, string>;
+  file: File | Blob;
+  key: string;
+  url: string;
+};
+declare class AwsS3Namespace extends BaseNamespace {
+  client: S3Client;
+  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, brotliOptions?: object, awsS3Options?: Options) => Promise<ReadFileResponse>;
+  readJsonBrotli: (bucket: string, key: string, brotliOptions?: object, awsS3Options?: Options) => Promise<ReadFileResponse>;
+  readBuffer: (bucket: string, key: string) => Promise<ReadBufferResponse>;
+  fileExists: (bucket: string, key: string) => Promise<boolean>;
+  readFile: (bucket: string, key: string, options?: Options) => Promise<ReadFileResponse>;
+  readJson: (bucket: string, key: string) => Promise<ReadFileResponse>;
+  readJsonGzip: (bucket: string, key: string, gzipOptions?: object, awsS3Options?: Options) => Promise<ReadFileResponse>;
+  readGzip: (bucket: string, key: string, gzipOptions?: object, awsS3Options?: Options) => Promise<ReadFileResponse>;
+  writeBrotli: (bucket: string, key: string, data: any, brotliOptions?: object, awsS3Options?: Options) => Promise<_$_aws_sdk_client_s30.PutObjectCommandOutput>;
+  writeFile: (bucket: string, key: string, data: any, options?: Options) => Promise<_$_aws_sdk_client_s30.PutObjectCommandOutput>;
+  writeJson: (bucket: string, key: string, data: any, options?: Options) => Promise<_$_aws_sdk_client_s30.PutObjectCommandOutput>;
+  writeJsonGzip: (bucket: string, key: string, data: any, gzipOptions?: object, awsS3Options?: Options) => Promise<_$_aws_sdk_client_s30.PutObjectCommandOutput>;
+  writeGzip: (bucket: string, key: string, data: any, gzipOptions?: object, awsS3Options?: Options) => Promise<_$_aws_sdk_client_s30.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>;
+}
+//#endregion
+export { AwsS3Namespace, ReadBufferResponse };