@8ms/helpers 2.4.8 → 2.4.9

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

@@ -0,0 +1,296 @@
+import { BaseNamespace } from "../../../_class/BaseNamespace.mjs";
+import { getToday } from "../../../date/calculation.mjs";
+import { getYmdHisString } from "../../../date/format.mjs";
+import "../../../date/index.mjs";
+import { getFolder } from "../../../string/getFolder.mjs";
+import { getStringFromStream } from "../../../string/getStringFromStream.mjs";
+import "../../../string/index.mjs";
+import { isResponse200 } from "../../server/isResponse200.mjs";
+import "../../server/index.mjs";
+import { getBrotliCompressed } from "../../../util/server/getBrotliCompressed.mjs";
+import { getBrotliDecompressed } from "../../../util/server/getBrotliDecompressed.mjs";
+import { getGzipCompressed } from "../../../util/server/getGzipCompressed.mjs";
+import { getGzipDecompressed } from "../../../util/server/getGzipDecompressed.mjs";
+import { readFileDefault } from "./awsS3.mjs";
+import "./index.mjs";
+//#region src/aws/s3/server/AwsS3Namespace.ts
+var AwsS3Namespace = class extends 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 = 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 = 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 = 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 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 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 = {
+				...readFileDefault,
+				buffer: void 0
+			};
+			const apiResponse = await this.client.send(new GetObjectCommand({
+				Bucket: bucket,
+				Key: key
+			}));
+			if (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 = 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(readFileDefault);
+			const today = getToday();
+			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 (isResponse200(apiResponse)) {
+					response.modified = getYmdHisString(apiResponse.LastModified);
+					response.body = await 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 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 getGzipDecompressed(apiResponse.body, gzipOptions);
+			return apiResponse;
+		};
+		this.writeBrotli = async (bucket, key, data, brotliOptions = {}, awsS3Options = {}) => {
+			await this.ensureInit();
+			let finalData = data;
+			finalData = await 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 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 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
+export { AwsS3Namespace };

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

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_date_date = require("../../../date/date.cjs");
+require("../../../date/index.cjs");
+const require_aws_server_aws = require("../../server/aws.cjs");
+require("../../server/index.cjs");
+const require_aws_s3_server_AwsS3Namespace = require("./AwsS3Namespace.cjs");
+//#region src/aws/s3/server/awsS3.ts
+const awsS3Namespaces = /* @__PURE__ */ new Map();
+const awsS3Client = async (key = "default", config, vaultId, itemId) => {
+	if (awsS3Namespaces.has(key)) return awsS3Namespaces.get(key);
+	const namespace = new require_aws_s3_server_AwsS3Namespace.AwsS3Namespace(key, await require_aws_server_aws.getConfig(key, config, vaultId, itemId));
+	awsS3Namespaces.set(key, namespace);
+	return namespace;
+};
+const readFileDefault = {
+	body: void 0,
+	now: void 0,
+	error: void 0,
+	modified: require_date_date.defaultDateTime
+};
+//#endregion
+exports.awsS3Client = awsS3Client;
+exports.readFileDefault = readFileDefault;

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

@@ -0,0 +1,16 @@
+import { AwsConfig } from "../../server/aws.cjs";
+import { AwsS3Namespace } from "./AwsS3Namespace.cjs";
+
+//#region src/aws/s3/server/awsS3.d.ts
+declare const awsS3Client: (key?: string, config?: AwsConfig, vaultId?: string, itemId?: string) => Promise<AwsS3Namespace>;
+type Modified = {
+  now: number;
+  modified: string;
+};
+type ReadFileResponse = Modified & {
+  body: any;
+  error: any;
+};
+declare const readFileDefault: ReadFileResponse;
+//#endregion
+export { Modified, ReadFileResponse, awsS3Client, readFileDefault };

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

@@ -0,0 +1,16 @@
+import { AwsConfig } from "../../server/aws.mjs";
+import { AwsS3Namespace } from "./AwsS3Namespace.mjs";
+
+//#region src/aws/s3/server/awsS3.d.ts
+declare const awsS3Client: (key?: string, config?: AwsConfig, vaultId?: string, itemId?: string) => Promise<AwsS3Namespace>;
+type Modified = {
+  now: number;
+  modified: string;
+};
+type ReadFileResponse = Modified & {
+  body: any;
+  error: any;
+};
+declare const readFileDefault: ReadFileResponse;
+//#endregion
+export { Modified, ReadFileResponse, awsS3Client, readFileDefault };

package/dist/aws/s3/server/awsS3.mjs

@@ -0,0 +1,21 @@
+import { defaultDateTime } from "../../../date/date.mjs";
+import "../../../date/index.mjs";
+import { getConfig } from "../../server/aws.mjs";
+import "../../server/index.mjs";
+import { AwsS3Namespace } from "./AwsS3Namespace.mjs";
+//#region src/aws/s3/server/awsS3.ts
+const awsS3Namespaces = /* @__PURE__ */ new Map();
+const awsS3Client = async (key = "default", config, vaultId, itemId) => {
+	if (awsS3Namespaces.has(key)) return awsS3Namespaces.get(key);
+	const namespace = new AwsS3Namespace(key, await getConfig(key, config, vaultId, itemId));
+	awsS3Namespaces.set(key, namespace);
+	return namespace;
+};
+const readFileDefault = {
+	body: void 0,
+	now: void 0,
+	error: void 0,
+	modified: defaultDateTime
+};
+//#endregion
+export { awsS3Client, readFileDefault };

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

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_aws_s3_server_awsS3 = require("./awsS3.cjs");
+const require_aws_s3_server_payload = require("./payload.cjs");
+const require_aws_s3_server_AwsS3Namespace = require("./AwsS3Namespace.cjs");
+exports.AwsS3Namespace = require_aws_s3_server_AwsS3Namespace.AwsS3Namespace;
+exports.awsS3Client = require_aws_s3_server_awsS3.awsS3Client;
+exports.payloadSchema = require_aws_s3_server_payload.payloadSchema;
+exports.readFileDefault = require_aws_s3_server_awsS3.readFileDefault;

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

@@ -0,0 +1,4 @@
+import { Modified, ReadFileResponse, awsS3Client, readFileDefault } from "./awsS3.cjs";
+import { PayloadSchemaType, payloadSchema } from "./payload.cjs";
+import { AwsS3Namespace, ReadBufferResponse } from "./AwsS3Namespace.cjs";
+export { AwsS3Namespace, Modified, PayloadSchemaType, ReadBufferResponse, ReadFileResponse, awsS3Client, payloadSchema, readFileDefault };

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

@@ -1,124 +1,4 @@
-import { t as BaseNamespace } from "../../../index-1SE8er2n.mjs";
-import { t as AwsConfig } from "../../../index-D-8_Li4c.mjs";
-import { z } from "zod/v4";
-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
-//#region src/aws/s3/server/awsS3.d.ts
-declare const awsS3Client: (key?: string, config?: AwsConfig, vaultId?: string, itemId?: string) => Promise<AwsS3Namespace>;
-type Modified = {
-  now: number;
-  modified: string;
-};
-type ReadFileResponse = Modified & {
-  body: any;
-  error: any;
-};
-declare const readFileDefault: ReadFileResponse;
-//#endregion
-//#region src/aws/s3/server/payload.d.ts
-/**
- * https://docs.aws.amazon.com/AmazonS3/latest/userguide/notification-content-structure.html
- */
-declare const payloadSchema: z.ZodObject<{
-  Records: z.ZodArray<z.ZodObject<{
-    eventVersion: z.ZodString;
-    eventSource: z.ZodString;
-    awsRegion: z.ZodString;
-    eventTime: z.ZodString;
-    eventName: z.ZodString;
-    userIdentity: z.ZodObject<{
-      principalId: z.ZodString;
-    }, z.core.$strip>;
-    requestParameters: z.ZodObject<{
-      sourceIPAddress: z.ZodString;
-    }, z.core.$strip>;
-    responseElements: z.ZodObject<{
-      "x-amz-request-id": z.ZodString;
-      "x-amz-id-2": z.ZodString;
-    }, z.core.$strip>;
-    s3: z.ZodObject<{
-      s3SchemaVersion: z.ZodString;
-      configurationId: z.ZodString;
-      bucket: z.ZodObject<{
-        name: z.ZodString;
-        ownerIdentity: z.ZodObject<{
-          principalId: z.ZodString;
-        }, z.core.$strip>;
-        arn: z.ZodString;
-      }, z.core.$strip>;
-      object: z.ZodObject<{
-        key: z.ZodString;
-        size: z.ZodString;
-        eTag: z.ZodString;
-        versionId: z.ZodOptional<z.ZodString>;
-        sequencer: z.ZodString;
-      }, z.core.$strip>;
-    }, z.core.$strip>;
-  }, z.core.$strip>>;
-}, z.core.$strip>;
-type PayloadSchemaType = z.infer<typeof payloadSchema>;
-//#endregion
+import { Modified, ReadFileResponse, awsS3Client, readFileDefault } from "./awsS3.mjs";
+import { PayloadSchemaType, payloadSchema } from "./payload.mjs";
+import { AwsS3Namespace, ReadBufferResponse } from "./AwsS3Namespace.mjs";
 export { AwsS3Namespace, Modified, PayloadSchemaType, ReadBufferResponse, ReadFileResponse, awsS3Client, payloadSchema, readFileDefault };