@8ms/helpers 2.3.26 → 2.3.28

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

@@ -0,0 +1,105 @@
+import { n as BaseClass, t as BaseNamespace } from "../../../index-DwB8X1lz.mjs";
+import { t as AwsConfig } from "../../../index-CqTOMR8f.mjs";
+import { SESClient, SendEmailCommandInput, SendRawEmailCommandInput } from "@aws-sdk/client-ses";
+
+//#region src/aws/ses/server/AwsSesNamespace.d.ts
+declare class AwsSesNamespace extends BaseNamespace {
+  client: SESClient;
+  config: AwsConfig;
+  ensureInit: () => Promise<void>;
+  send: (input: SendEmailCommandInput | SendRawEmailCommandInput) => Promise<any>;
+}
+//#endregion
+//#region src/aws/ses/server/SimpleEmail.d.ts
+type AttachmentSource = {
+  filename: string;
+  contentType?: string;
+  data?: string;
+  url?: string;
+};
+type ConstructorProps = {
+  bcc?: string[];
+  cc?: string[];
+  from?: string;
+  html?: string;
+  subject?: string;
+  to?: string | string[];
+  attachments?: AttachmentSource[];
+};
+/**
+ * Class to build and send an AWS SES email.
+ */
+declare class SimpleEmail extends BaseClass {
+  from?: string;
+  to: string[];
+  cc: string[];
+  bcc: string[];
+  html?: string;
+  subject?: string;
+  attachments: AttachmentSource[];
+  constructor({
+    bcc,
+    cc,
+    from,
+    html,
+    subject,
+    to,
+    attachments
+  }: ConstructorProps);
+  setFrom: (from: string) => this;
+  setHtml: (html: string) => this;
+  setSubject: (subject: string) => this;
+  setAttachments: (attachments: AttachmentSource[]) => this;
+  addAttachment: (attachment: AttachmentSource) => this;
+  addAttachmentFromdata: (filename: string, data: string, contentType?: string) => this;
+  addAttachmentFromUrl: (filename: string, url: string, contentType?: string) => this;
+  clearAttachments: () => this;
+  pushBcc: (recipient: string | string[]) => this;
+  pushCc: (recipient: string | string[]) => this;
+  pushTo: (recipient: string | string[]) => this;
+  setBcc: (recipient: string | string[]) => this;
+  setCc: (recipient: string | string[]) => this;
+  setTo: (recipient: string | string[]) => this;
+  getSendParam: () => Promise<{
+    Destinations: string[];
+    RawMessage: {
+      Data: string;
+    };
+    Source: string;
+  } | {
+    Destination: {
+      BccAddresses: string[];
+      CcAddresses: string[];
+      ToAddresses: string[];
+    };
+    Message: {
+      Body: {
+        Html: {
+          Charset: string;
+          Data: string;
+        };
+        Text: {
+          Charset: string;
+          Data: string;
+        };
+      };
+      Subject: {
+        Charset: string;
+        Data: string;
+      };
+    };
+    Source: string;
+  }>;
+  private _getRawEmailParams;
+  private _isTextFile;
+  private _getAttachmentTextData;
+  private _getAttachmentData;
+  private _isBase64;
+  private _getContentTypeFromFilename;
+  private _filterRecipients;
+}
+//#endregion
+//#region src/aws/ses/server/awsSes.d.ts
+declare const awsSesClient: (key?: string, config?: AwsConfig, vaultId?: string, itemId?: string) => Promise<AwsSesNamespace>;
+//#endregion
+export { AwsSesNamespace, SimpleEmail, awsSesClient };

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

@@ -0,0 +1,268 @@
+import { BaseClass, BaseNamespace } from "../../../_class/index.mjs";
+import { t as getConfig } from "../../../server-Bwy4JI8Z.mjs";
+
+//#region src/aws/ses/server/AwsSesNamespace.ts
+var AwsSesNamespace = class extends BaseNamespace {
+	ensureInit = async () => {
+		if (!this.client) try {
+			const { SESClient } = await import("@aws-sdk/client-ses");
+			this.client = new SESClient(this.config);
+		} catch (e) {
+			throw new Error("AWS SES Client not installed");
+		}
+	};
+	send = async (input) => {
+		await this.ensureInit();
+		let response;
+		if (input?.Message?.Body?.Html?.Data) try {
+			const { SendEmailCommand } = await import("@aws-sdk/client-ses");
+			const command = new SendEmailCommand(input);
+			response = await this.client.send(command);
+		} catch (exception) {
+			response = exception;
+		}
+		else try {
+			const { SendRawEmailCommand } = await import("@aws-sdk/client-ses");
+			const command = new SendRawEmailCommand(input);
+			response = await this.client.send(command);
+		} catch (exception) {
+			response = exception;
+		}
+		return response;
+	};
+};
+
+//#endregion
+//#region src/aws/ses/server/SimpleEmail.ts
+/**
+* Class to build and send an AWS SES email.
+*/
+var SimpleEmail = class extends BaseClass {
+	from;
+	to = [];
+	cc = [];
+	bcc = [];
+	html;
+	subject;
+	attachments = [];
+	constructor({ bcc, cc, from, html, subject, to, attachments }) {
+		super();
+		if (bcc) this.setBcc(bcc);
+		if (cc) this.setCc(cc);
+		if (from) this.setFrom(from);
+		if (html) this.setHtml(html);
+		if (subject) this.setSubject(subject);
+		if (to) this.setTo(to);
+		if (attachments) this.setAttachments(attachments);
+		return this;
+	}
+	setFrom = (from) => {
+		return this._setValue("from", from);
+	};
+	setHtml = (html) => {
+		return this._setValue("html", html);
+	};
+	setSubject = (subject) => {
+		return this._setValue("subject", subject);
+	};
+	setAttachments = (attachments) => {
+		return this._setValue("attachments", attachments);
+	};
+	addAttachment = (attachment) => {
+		this.attachments.push(attachment);
+		return this;
+	};
+	addAttachmentFromdata = (filename, data, contentType) => {
+		return this.addAttachment({
+			filename,
+			data,
+			contentType: contentType || this._getContentTypeFromFilename(filename)
+		});
+	};
+	addAttachmentFromUrl = (filename, url, contentType) => {
+		return this.addAttachment({
+			filename,
+			url,
+			contentType: contentType || this._getContentTypeFromFilename(filename)
+		});
+	};
+	clearAttachments = () => {
+		this.attachments = [];
+		return this;
+	};
+	pushBcc = (recipient) => {
+		return this._push("bcc", recipient);
+	};
+	pushCc = (recipient) => {
+		return this._push("cc", recipient);
+	};
+	pushTo = (recipient) => {
+		return this._push("to", recipient);
+	};
+	setBcc = (recipient) => {
+		return this._setArray("bcc", recipient);
+	};
+	setCc = (recipient) => {
+		return this._setArray("cc", recipient);
+	};
+	setTo = (recipient) => {
+		return this._setArray("to", recipient);
+	};
+	getSendParam = async () => {
+		if (this.attachments.length > 0) return await this._getRawEmailParams();
+		return {
+			Destination: {
+				BccAddresses: this._filterRecipients("bcc"),
+				CcAddresses: this._filterRecipients("cc"),
+				ToAddresses: this._filterRecipients("to")
+			},
+			Message: {
+				Body: {
+					Html: {
+						Charset: "UTF-8",
+						Data: this.html
+					},
+					Text: {
+						Charset: "UTF-8",
+						Data: this.html
+					}
+				},
+				Subject: {
+					Charset: "UTF-8",
+					Data: this.subject
+				}
+			},
+			Source: this.from
+		};
+	};
+	_getRawEmailParams = async () => {
+		const boundary = `----=_NextPart_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+		const allRecipients = [
+			...this._filterRecipients("to"),
+			...this._filterRecipients("cc"),
+			...this._filterRecipients("bcc")
+		];
+		let rawMessage = "";
+		rawMessage += `From: ${this.from}\r\n`;
+		if (this._filterRecipients("to").length > 0) rawMessage += `To: ${this._filterRecipients("to").join(", ")}\r\n`;
+		if (this._filterRecipients("cc").length > 0) rawMessage += `Cc: ${this._filterRecipients("cc").join(", ")}\r\n`;
+		rawMessage += `Subject: ${this.subject}\r\n`;
+		rawMessage += `MIME-Version: 1.0\r\n`;
+		rawMessage += `Content-Type: multipart/mixed; boundary="${boundary}"\r\n\r\n`;
+		rawMessage += `--${boundary}\r\n`;
+		rawMessage += `Content-Type: text/html; charset=UTF-8\r\n`;
+		rawMessage += `Content-Transfer-Encoding: 7bit\r\n\r\n`;
+		rawMessage += `${this.html}\r\n\r\n`;
+		for (const attachment of this.attachments) {
+			const isTextFile = this._isTextFile(attachment.contentType || this._getContentTypeFromFilename(attachment.filename));
+			rawMessage += `--${boundary}\r\n`;
+			rawMessage += `Content-Type: ${attachment.contentType || "application/octet-stream"}\r\n`;
+			rawMessage += `Content-Disposition: attachment; filename="${attachment.filename}"\r\n`;
+			if (isTextFile) {
+				rawMessage += `Content-Transfer-Encoding: 7bit\r\n\r\n`;
+				const textData = await this._getAttachmentTextData(attachment);
+				rawMessage += `${textData}\r\n\r\n`;
+			} else {
+				rawMessage += `Content-Transfer-Encoding: base64\r\n\r\n`;
+				const attachmentData = await this._getAttachmentData(attachment);
+				rawMessage += `${attachmentData}\r\n\r\n`;
+			}
+		}
+		rawMessage += `--${boundary}--\r\n`;
+		return {
+			Destinations: allRecipients,
+			RawMessage: { Data: rawMessage },
+			Source: this.from
+		};
+	};
+	_isTextFile = (contentType) => {
+		return [
+			"text/csv",
+			"text/plain",
+			"text/html",
+			"application/json",
+			"application/xml",
+			"text/xml"
+		].some((type) => contentType.startsWith(type));
+	};
+	_getAttachmentTextData = async (attachment) => {
+		if (attachment.data) {
+			const base64Data = attachment.data.replace(/^data:[^;]+;base64,/, "");
+			if (this._isBase64(base64Data)) return Buffer.from(base64Data, "base64").toString("utf-8");
+			return attachment.data;
+		}
+		if (attachment.url) return await (await (await import("node-fetch").then((mod) => mod.default))(attachment.url)).text();
+		throw new Error(`No valid data source provided for attachment: ${attachment.filename}`);
+	};
+	_getAttachmentData = async (attachment) => {
+		if (attachment.data) {
+			const cleanData = attachment.data.replace(/^data:[^;]+;base64,/, "");
+			if (this._isBase64(cleanData)) return cleanData;
+			return Buffer.from(attachment.data, "utf-8").toString("base64");
+		}
+		if (attachment.url) return (await (await (await import("node-fetch").then((mod) => mod.default))(attachment.url)).buffer()).toString("base64");
+		throw new Error(`No valid data source provided for attachment: ${attachment.filename}`);
+	};
+	_isBase64 = (str) => {
+		try {
+			return Buffer.from(str, "base64").toString("base64") === str;
+		} catch {
+			return false;
+		}
+	};
+	_getContentTypeFromFilename = (filename) => {
+		const extension = filename.split(".").pop()?.toLowerCase();
+		return {
+			"jpg": "image/jpeg",
+			"jpeg": "image/jpeg",
+			"png": "image/png",
+			"gif": "image/gif",
+			"svg": "image/svg+xml",
+			"webp": "image/webp",
+			"bmp": "image/bmp",
+			"ico": "image/x-icon",
+			"pdf": "application/pdf",
+			"doc": "application/msword",
+			"docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+			"xls": "application/vnd.ms-excel",
+			"xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+			"ppt": "application/vnd.ms-powerpoint",
+			"pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+			"csv": "text/csv",
+			"tsv": "text/tab-separated-values",
+			"json": "application/json",
+			"xml": "application/xml",
+			"txt": "text/plain",
+			"zip": "application/zip",
+			"rar": "application/x-rar-compressed",
+			"7z": "application/x-7z-compressed",
+			"tar": "application/x-tar",
+			"gz": "application/gzip",
+			"mp3": "audio/mpeg",
+			"wav": "audio/wav",
+			"mp4": "video/mp4",
+			"avi": "video/x-msvideo",
+			"mov": "video/quicktime"
+		}[extension || ""] || "application/octet-stream";
+	};
+	_filterRecipients = (field) => {
+		let response = this[field].filter((recipient) => recipient && null !== recipient);
+		response = response.map((recipient) => recipient.toLowerCase().trim());
+		response = response.filter((recipient) => "" !== recipient);
+		response = [...new Set(response)];
+		return response;
+	};
+};
+
+//#endregion
+//#region src/aws/ses/server/awsSes.ts
+const awsSesNamespaces = /* @__PURE__ */ new Map();
+const awsSesClient = async (key = "default", config, vaultId, itemId) => {
+	if (awsSesNamespaces.has(key)) return awsSesNamespaces.get(key);
+	const namespace = new AwsSesNamespace(key, await getConfig(key, config, vaultId, itemId));
+	awsSesNamespaces.set(key, namespace);
+	return namespace;
+};
+
+//#endregion
+export { AwsSesNamespace, SimpleEmail, awsSesClient };

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

@@ -0,0 +1,41 @@
+import { t as BaseNamespace } from "../../../index-DwB8X1lz.mjs";
+import { t as AwsConfig } from "../../../index-CqTOMR8f.mjs";
+import * as _aws_sdk_client_sqs0 from "@aws-sdk/client-sqs";
+import { SQSClient } from "@aws-sdk/client-sqs";
+
+//#region src/aws/sqs/server/AwsSqsNamespace.d.ts
+type SqsEventRecord = {
+  messageId: string;
+  receiptHandle: string;
+  body: any;
+  attributes: object;
+  messageAttributes: object;
+  md5OfMessageAttributes: string;
+  md5OfBody: string;
+  eventSource: string;
+  eventSourceARN: string;
+  awsRegion: string;
+};
+type SqsEvent = {
+  Records: SqsEventRecord[];
+};
+type AddToQueue = {
+  data: any;
+  dedupeId: string;
+  groupId?: string;
+  queueId?: string;
+  queueUrl: string;
+};
+declare class AwsSqsNamespace extends BaseNamespace {
+  client: SQSClient;
+  config: AwsConfig;
+  ensureInit: () => Promise<void>;
+  addToQueue: (props: AddToQueue) => Promise<_aws_sdk_client_sqs0.SendMessageCommandOutput>;
+  deleteFromQueue: (queueUrl: string, recipientHandle: string) => Promise<_aws_sdk_client_sqs0.DeleteMessageCommandOutput>;
+  isEventSqs: (event: SqsEvent) => Promise<boolean>;
+}
+//#endregion
+//#region src/aws/sqs/server/awsSqs.d.ts
+declare const awsSqsClient: (key?: string, config?: AwsConfig, vaultId?: string, itemId?: string) => Promise<AwsSqsNamespace>;
+//#endregion
+export { AwsSqsNamespace, awsSqsClient };

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

@@ -0,0 +1,56 @@
+import { BaseNamespace } from "../../../_class/index.mjs";
+import { t as getConfig } from "../../../server-Bwy4JI8Z.mjs";
+
+//#region src/aws/sqs/server/AwsSqsNamespace.ts
+var AwsSqsNamespace = class extends BaseNamespace {
+	ensureInit = async () => {
+		if (!this.client) try {
+			const { SQSClient } = await import("@aws-sdk/client-sqs");
+			this.client = new SQSClient(this.config);
+		} catch (e) {
+			throw new Error("AWS SQS Client not installed");
+		}
+	};
+	addToQueue = async (props) => {
+		await this.ensureInit();
+		const { SendMessageCommand } = await import("@aws-sdk/client-sqs");
+		let params = {
+			MessageBody: JSON.stringify({
+				queueId: props.queueId,
+				data: props.data
+			}),
+			QueueUrl: props.queueUrl
+		};
+		if (void 0 !== props?.dedupeId) params["MessageDeduplicationId"] = props.dedupeId;
+		if (void 0 !== props?.groupId) params["MessageGroupId"] = props.dedupeId;
+		return await this.client.send(new SendMessageCommand(params));
+	};
+	deleteFromQueue = async (queueUrl, recipientHandle) => {
+		await this.ensureInit();
+		const { DeleteMessageCommand } = await import("@aws-sdk/client-sqs");
+		const params = {
+			QueueUrl: queueUrl,
+			ReceiptHandle: recipientHandle
+		};
+		return await this.client.send(new DeleteMessageCommand(params));
+	};
+	isEventSqs = async (event) => {
+		await this.ensureInit();
+		let response = false;
+		if (void 0 !== event["Records"]) for (let i = 0; i < event["Records"].length; i++);
+		return response;
+	};
+};
+
+//#endregion
+//#region src/aws/sqs/server/awsSqs.ts
+const awsSqsNamespaces = /* @__PURE__ */ new Map();
+const awsSqsClient = async (key = "default", config, vaultId, itemId) => {
+	if (awsSqsNamespaces.has(key)) return awsSqsNamespaces.get(key);
+	const namespace = new AwsSqsNamespace(key, await getConfig(key, config, vaultId, itemId));
+	awsSqsNamespaces.set(key, namespace);
+	return namespace;
+};
+
+//#endregion
+export { AwsSqsNamespace, awsSqsClient };

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

@@ -0,0 +1,18 @@
+import { t as BaseNamespace } from "../../../index-DwB8X1lz.mjs";
+import { t as AwsConfig } from "../../../index-CqTOMR8f.mjs";
+import { SSMClient } from "@aws-sdk/client-ssm";
+
+//#region src/aws/ssm/server/AwsSsmNamespace.d.ts
+declare class AwsSsmNamespace extends BaseNamespace {
+  client: SSMClient;
+  config: AwsConfig;
+  parameters: Map<string, any>;
+  constructor(key: string, config: any);
+  ensureInit: () => Promise<void>;
+  getParameter: (name: string, withDecryption?: boolean, isJson?: boolean) => Promise<any>;
+}
+//#endregion
+//#region src/aws/ssm/server/awsSsm.d.ts
+declare const awsSsmClient: (key?: string, config?: AwsConfig, vaultId?: string, itemId?: string) => Promise<AwsSsmNamespace>;
+//#endregion
+export { AwsSsmNamespace, awsSsmClient };

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

@@ -0,0 +1,47 @@
+import { BaseNamespace } from "../../../_class/index.mjs";
+import { t as getConfig } from "../../../server-Bwy4JI8Z.mjs";
+
+//#region src/aws/ssm/server/AwsSsmNamespace.ts
+var AwsSsmNamespace = class extends BaseNamespace {
+	parameters;
+	constructor(key, config) {
+		super(key, config);
+		this.parameters = /* @__PURE__ */ new Map();
+	}
+	ensureInit = async () => {
+		if (!this.client) try {
+			const { SSMClient } = await import("@aws-sdk/client-ssm");
+			this.client = new SSMClient(this.config);
+		} catch (e) {
+			throw new Error("AWS SSM Client not installed");
+		}
+	};
+	getParameter = async (name, withDecryption = false, isJson = true) => {
+		await this.ensureInit();
+		if (!this.parameters.has(name)) {
+			const { GetParameterCommand } = await import("@aws-sdk/client-ssm");
+			const apiResponse = await this.client.send(new GetParameterCommand({
+				Name: name,
+				WithDecryption: void 0 === withDecryption ? true : withDecryption
+			}));
+			if (apiResponse.Parameter.Value) if (void 0 === apiResponse.Parameter.Value) this.parameters.set(name, null);
+			else if (void 0 === isJson || true === isJson) this.parameters.set(name, JSON.parse(apiResponse.Parameter.Value) || null);
+			else this.parameters.set(name, apiResponse.Parameter.Value);
+			else this.parameters.set(name, null);
+		}
+		return this.parameters.get(name);
+	};
+};
+
+//#endregion
+//#region src/aws/ssm/server/awsSsm.ts
+const awsSsmNamespaces = /* @__PURE__ */ new Map();
+const awsSsmClient = async (key = "default", config, vaultId, itemId) => {
+	if (awsSsmNamespaces.has(key)) return awsSsmNamespaces.get(key);
+	const namespace = new AwsSsmNamespace(key, await getConfig(key, config, vaultId, itemId));
+	awsSsmNamespaces.set(key, namespace);
+	return namespace;
+};
+
+//#endregion
+export { AwsSsmNamespace, awsSsmClient };

package/dist/axios/index.d.mts

@@ -0,0 +1,22 @@
+import { f as ApiResponseClass } from "../index-DW9yJLtI.mjs";
+
+//#region src/axios/deleteRequest.d.ts
+/**
+ * Make a DELETE request.
+ * Can't use the function name delete as it's reserved
+ */
+declare const deleteRequest: (url: string, config?: {}) => Promise<ApiResponseClass>;
+//#endregion
+//#region src/axios/get.d.ts
+/**
+ * Make a GET request.
+ */
+declare const get: (url: string, config?: {}) => Promise<ApiResponseClass>;
+//#endregion
+//#region src/axios/post.d.ts
+/**
+ * Make a POST request.
+ */
+declare const post: (url: string, data?: {}, config?: {}) => Promise<ApiResponseClass>;
+//#endregion
+export { deleteRequest, get, post };

package/dist/axios/index.mjs

@@ -0,0 +1,50 @@
+import { u as ApiResponseClass } from "../api-DGKJDAfb.mjs";
+import axios from "axios";
+
+//#region src/axios/deleteRequest.ts
+/**
+* Make a DELETE request.
+* Can't use the function name delete as it's reserved
+*/
+const deleteRequest = async (url, config = {}) => {
+	return await axios.delete(url, config).then(async (response) => {
+		if (void 0 !== response.data.body && void 0 !== response.data.error && void 0 !== response.data.state) return new ApiResponseClass(response.data);
+		else if (response.status >= 200 && response.status <= 299) return new ApiResponseClass().setToSuccess(response.data);
+		return new ApiResponseClass().setToError(response.data, response.statusText);
+	}).catch((error) => {
+		return new ApiResponseClass().setToError(null, error.message);
+	});
+};
+
+//#endregion
+//#region src/axios/get.ts
+/**
+* Make a GET request.
+*/
+const get = async (url, config = {}) => {
+	return await axios.get(url, config).then(async (response) => {
+		if (void 0 !== response.data.body && void 0 !== response.data.error && void 0 !== response.data.state) return new ApiResponseClass(response.data);
+		else if (response.status >= 200 && response.status <= 299) return new ApiResponseClass().setToSuccess(response.data);
+		return new ApiResponseClass().setToError(response.data, response.statusText);
+	}).catch((error) => {
+		return new ApiResponseClass().setToError(null, error.message);
+	});
+};
+
+//#endregion
+//#region src/axios/post.ts
+/**
+* Make a POST request.
+*/
+const post = async (url, data = {}, config = {}) => {
+	return await axios.post(url, data, config).then(async (response) => {
+		if (void 0 !== response.data.body && void 0 !== response.data.error && void 0 !== response.data.state) return new ApiResponseClass(response.data);
+		else if (response.status >= 200 && response.status <= 299) return new ApiResponseClass().setToSuccess(response.data);
+		return new ApiResponseClass().setToError(response.data, response.statusText);
+	}).catch((error) => {
+		return new ApiResponseClass().setToError(null, error.message);
+	});
+};
+
+//#endregion
+export { deleteRequest, get, post };

package/dist/boolean/index.d.mts

@@ -0,0 +1,7 @@
+//#region src/boolean/boolean.d.ts
+/**
+ * Convert an input from a variety of forms into boolean.
+ */
+declare const getBoolean: (input: any, defaultValue?: boolean) => boolean;
+//#endregion
+export { getBoolean };

package/dist/boolean/index.mjs

@@ -0,0 +1,13 @@
+//#region src/boolean/boolean.ts
+/**
+* Convert an input from a variety of forms into boolean.
+*/
+const getBoolean = (input, defaultValue = false) => {
+	if ("boolean" === typeof input) return input;
+	else if ("string" === typeof input) return "true" === input || "1" === input || "yes" === input || "y" === input;
+	else if ("number" === typeof input) return 1 === input;
+	return defaultValue;
+};
+
+//#endregion
+export { getBoolean };