@8ms/helpers 2.3.5 → 2.3.6

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

@@ -0,0 +1,19 @@
+import { t as BaseNamespace } from "../../../index-CFaAdPAh.mjs";
+import { t as AwsConfig } from "../../../index-B4K9Z1U-.mjs";
+import { GlueClient } from "@aws-sdk/client-glue";
+
+//#region src/aws/glue/server/AwsGlueNamespace.d.ts
+declare class AwsGlueNamespace extends BaseNamespace {
+  client: GlueClient;
+  config: AwsConfig;
+  ensureInit: () => Promise<void>;
+  /**
+   * Invoke an AWS Glue Crawler by passing in the name of the Crawler.
+   */
+  invoke: (crawler: string) => Promise<boolean>;
+}
+//#endregion
+//#region src/aws/glue/server/awsGlue.d.ts
+declare const awsGlueClient: (key?: string, config?: AwsConfig, vaultId?: string, itemId?: string) => Promise<AwsGlueNamespace>;
+//#endregion
+export { AwsGlueNamespace, awsGlueClient };

package/dist/aws/glue/server/index.mjs

@@ -0,0 +1,36 @@
+import { BaseNamespace } from "../../../_class/index.mjs";
+import { n as isResponse200, t as getConfig } from "../../../server-Bwy4JI8Z.mjs";
+
+//#region src/aws/glue/server/AwsGlueNamespace.ts
+var AwsGlueNamespace = class extends BaseNamespace {
+	ensureInit = async () => {
+		if (!this.client) try {
+			const { GlueClient } = await import("@aws-sdk/client-glue");
+			this.client = new GlueClient(this.config);
+		} catch (e) {
+			throw new Error("AWS Glue Client not installed");
+		}
+	};
+	/**
+	* Invoke an AWS Glue Crawler by passing in the name of the Crawler.
+	*/
+	invoke = async (crawler) => {
+		await this.ensureInit();
+		const { StartCrawlerCommand } = await import("@aws-sdk/client-glue");
+		const command = new StartCrawlerCommand({ Name: crawler });
+		return isResponse200(await this.client.send(command));
+	};
+};
+
+//#endregion
+//#region src/aws/glue/server/awsGlue.ts
+const awsGlueNamespaces = /* @__PURE__ */ new Map();
+const awsGlueClient = async (key = "default", config, vaultId, itemId) => {
+	if (awsGlueNamespaces.has(key)) return awsGlueNamespaces.get(key);
+	const namespace = new AwsGlueNamespace(key, await getConfig(key, config, vaultId, itemId));
+	awsGlueNamespaces.set(key, namespace);
+	return namespace;
+};
+
+//#endregion
+export { AwsGlueNamespace, awsGlueClient };

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

@@ -0,0 +1,28 @@
+import { t as BaseNamespace } from "../../../index-CFaAdPAh.mjs";
+import { t as AwsConfig } from "../../../index-B4K9Z1U-.mjs";
+import { LambdaClient } from "@aws-sdk/client-lambda";
+
+//#region src/aws/lambda/server/AwsLambdaNamespace.d.ts
+type InvokeProps = {
+  awaitResponse?: boolean;
+  functionName: string;
+  isJson?: boolean;
+  payload?: object;
+};
+declare class AwsLambdaNamespace extends BaseNamespace {
+  client: LambdaClient;
+  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>;
+}
+//#endregion
+//#region src/aws/lambda/server/awsLambda.d.ts
+declare const awsLambdaClient: (key?: string, config?: AwsConfig, vaultId?: string, itemId?: string) => Promise<AwsLambdaNamespace>;
+declare const getHandlerPath: (input: string) => string;
+//#endregion
+export { AwsLambdaNamespace, awsLambdaClient, getHandlerPath };

package/dist/aws/lambda/server/index.mjs

@@ -0,0 +1,57 @@
+import { BaseNamespace } from "../../../_class/index.mjs";
+import { u as ApiResponseClass } from "../../../api-DGKJDAfb.mjs";
+import { n as isResponse200, t as getConfig } from "../../../server-Bwy4JI8Z.mjs";
+
+//#region src/aws/lambda/server/AwsLambdaNamespace.ts
+var AwsLambdaNamespace = class extends BaseNamespace {
+	ensureInit = async () => {
+		if (!this.client) try {
+			const { LambdaClient } = await import("@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
+	*/
+	invoke = async (props) => {
+		await this.ensureInit();
+		const { InvokeCommand } = await import("@aws-sdk/client-lambda");
+		let response = false;
+		const params = {
+			FunctionName: props.functionName,
+			InvocationType: true === props.awaitResponse ? "RequestResponse" : "Event"
+		};
+		if (void 0 !== props.payload) params["Payload"] = new Uint8Array(Buffer.from(JSON.stringify(props.payload)));
+		const command = new InvokeCommand(params);
+		const apiResponse = await this.client.send(command);
+		if (isResponse200(apiResponse)) if (props.awaitResponse && void 0 !== apiResponse.Payload) {
+			response = new TextDecoder("ascii").decode(apiResponse.Payload);
+			if (true === props.isJson) {
+				response = JSON.parse(response);
+				if ("string" === typeof response) response = JSON.parse(response);
+				if (void 0 !== response && void 0 !== response?.error && void 0 !== response?.state) response = new ApiResponseClass().fromJson(response);
+			}
+		} else response = true;
+		return response;
+	};
+};
+
+//#endregion
+//#region src/aws/lambda/server/awsLambda.ts
+const awsLambdaNamespaces = /* @__PURE__ */ new Map();
+const awsLambdaClient = async (key = "default", config, vaultId, itemId) => {
+	if (awsLambdaNamespaces.has(key)) return awsLambdaNamespaces.get(key);
+	const namespace = new AwsLambdaNamespace(key, await getConfig(key, config, vaultId, itemId));
+	awsLambdaNamespaces.set(key, namespace);
+	return namespace;
+};
+const getHandlerPath = (input) => {
+	return `${input.split(process.cwd())[1].substring(1).replace(/\\/g, "/")}`;
+};
+
+//#endregion
+export { AwsLambdaNamespace, awsLambdaClient, getHandlerPath };

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

@@ -0,0 +1,124 @@
+import { t as BaseNamespace } from "../../../index-CFaAdPAh.mjs";
+import { t as AwsConfig } from "../../../index-B4K9Z1U-.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: any;
+  file: any;
+  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
+export { AwsS3Namespace, Modified, PayloadSchemaType, ReadBufferResponse, ReadFileResponse, awsS3Client, payloadSchema, readFileDefault };

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

@@ -0,0 +1,361 @@
+import { BaseNamespace } from "../../../_class/index.mjs";
+import { defaultDateTime, getToday, getYmdHisString } from "../../../date/index.mjs";
+import { getFolder, getStringFromStream } from "../../../string/index.mjs";
+import { n as isResponse200, t as getConfig } from "../../../server-Bwy4JI8Z.mjs";
+import { getBrotliCompressed, getBrotliDecompressed, getGzipCompressed, getGzipDecompressed } from "../../../util/server/index.mjs";
+import { z } from "zod/v4";
+import axios from "axios";
+import cloneDeep from "lodash/cloneDeep";
+
+//#region src/aws/s3/server/AwsS3Namespace.ts
+var AwsS3Namespace = class 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
+		}));
+	};
+	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);
+		const apiResponse = await this.client.send(new ListObjectsV2Command({
+			Bucket: bucket,
+			Prefix: "" === cleanFolder ? "" : cleanFolder + "/"
+		}));
+		if (apiResponse.Contents.length === 0) 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);
+	};
+	/**
+	* 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 + "/"
+		}));
+		if (void 0 !== apiResponse["Contents"]) {
+			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();
+		return await this.iterateFolders(bucket, folder);
+	};
+	/**
+	* 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 + "/"
+		}));
+		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;
+	};
+	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);
+		if (void 0 !== 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 (void 0 !== 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: 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) => {
+				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;
+	};
+	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;
+	};
+	readFile = async (bucket, key, options = {}) => {
+		await this.ensureInit();
+		let response = cloneDeep(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;
+	};
+	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 (void 0 !== apiResponse.body) {
+			apiResponse.body = await 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 (void 0 !== 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);
+		return await this.writeFile(bucket, key, finalData, awsS3Options);
+	};
+	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
+		}));
+	};
+	writeJson = async (bucket, key, data, options = {}) => {
+		await this.ensureInit();
+		return await this.writeFile(bucket, key, JSON.stringify(data), options);
+	};
+	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);
+	};
+	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);
+	};
+	/**
+	* 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);
+			});
+			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);
+			}
+		});
+	};
+	/**
+	* Download a file and write to S3.
+	*/
+	urlContents = async (bucket, key, url) => {
+		await this.ensureInit();
+		return axios(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"]
+			});
+		});
+	};
+};
+
+//#endregion
+//#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
+//#region src/aws/s3/server/payload.ts
+/**
+* https://docs.aws.amazon.com/AmazonS3/latest/userguide/notification-content-structure.html
+*/
+const payloadSchema = z.object({ Records: z.object({
+	eventVersion: z.string(),
+	eventSource: z.string(),
+	awsRegion: z.string(),
+	eventTime: z.string(),
+	eventName: z.string(),
+	userIdentity: z.object({ principalId: z.string() }),
+	requestParameters: z.object({ sourceIPAddress: z.string() }),
+	responseElements: z.object({
+		"x-amz-request-id": z.string(),
+		"x-amz-id-2": z.string()
+	}),
+	s3: z.object({
+		s3SchemaVersion: z.string(),
+		configurationId: z.string(),
+		bucket: z.object({
+			name: z.string(),
+			ownerIdentity: z.object({ principalId: z.string() }),
+			arn: z.string()
+		}),
+		object: z.object({
+			key: z.string(),
+			size: z.string(),
+			eTag: z.string(),
+			versionId: z.string().optional(),
+			sequencer: z.string()
+		})
+	})
+}).array() });
+
+//#endregion
+export { AwsS3Namespace, awsS3Client, payloadSchema, readFileDefault };

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

@@ -0,0 +1,2 @@
+import { n as getConfig, r as isResponse200, t as AwsConfig } from "../../index-B4K9Z1U-.mjs";
+export { AwsConfig, getConfig, isResponse200 };

package/dist/aws/server/index.mjs

@@ -0,0 +1,3 @@
+import { n as isResponse200, t as getConfig } from "../../server-Bwy4JI8Z.mjs";
+
+export { getConfig, isResponse200 };