@8ms/helpers 1.41.1 → 1.42.0

package/dist/esm/aws/s3/writeBrotli.d.ts

@@ -0,0 +1,12 @@
+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>;
+export default writeBrotli;

package/dist/esm/aws/s3/writeBrotli.js

@@ -0,0 +1,23 @@
+import getBrotliCompressed from "../../util/getBrotliCompressed";
+import writeFile from "./writeFile";
+/**
+ * Write a brotli file to S3.
+ */
+const writeBrotli = async ({ bucket, data, key, isJson, ...options }) => {
+    let finalData = data;
+    if (false !== isJson) {
+        finalData = JSON.stringify(data);
+    }
+    // Compress the data
+    const brotliData = await getBrotliCompressed({
+        input: finalData,
+    });
+    const apiResponse = await writeFile({
+        bucket,
+        data: brotliData,
+        key,
+        ...options,
+    });
+    return apiResponse;
+};
+export default writeBrotli;

package/dist/esm/aws/s3/writeFile.d.ts

@@ -0,0 +1,11 @@
+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>;
+export default writeFile;

package/dist/esm/aws/s3/writeFile.js

@@ -0,0 +1,14 @@
+/**
+ * Write a file to S3.
+ */
+const writeFile = async ({ bucket, data, key, ...options }) => {
+    const { PutObjectCommand } = require('@aws-sdk/client-s3');
+    const apiResponse = await global.awsS3Client.send(new PutObjectCommand({
+        Bucket: bucket,
+        Body: data,
+        Key: key,
+        ...options,
+    }));
+    return apiResponse;
+};
+export default writeFile;

package/dist/esm/aws/s3/writeGzip.d.ts

@@ -0,0 +1,12 @@
+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>;
+export default writeGzip;

package/dist/esm/aws/s3/writeGzip.js

@@ -0,0 +1,23 @@
+import getGzipCompressed from "../../util/getGzipCompressed";
+import writeFile from "./writeFile";
+/**
+ * Write a gzip file to S3.
+ */
+const writeGzip = async ({ bucket, data, key, isJson, ...options }) => {
+    let finalData = data;
+    if (false !== isJson) {
+        finalData = JSON.stringify(data);
+    }
+    // Compress the data
+    const brotliData = await getGzipCompressed({
+        input: finalData,
+    });
+    const apiResponse = await writeFile({
+        bucket,
+        data: brotliData,
+        key,
+        ...options,
+    });
+    return apiResponse;
+};
+export default writeGzip;

package/dist/esm/aws/s3/writePresignedPost.d.ts

@@ -0,0 +1,14 @@
+import { Config } from '../getConfig';
+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>;
+export default writePresignedPost;

package/dist/esm/aws/s3/writePresignedPost.js

@@ -0,0 +1,29 @@
+/**
+ * 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]) => {
+            // @ts-ignore
+            formData.append(key, value);
+        });
+        const upload = await fetch(url, {
+            method: 'POST',
+            body: formData,
+        });
+        // Uploaded to S3
+        if (upload.ok) {
+            response = `https://${bucket}.s3.${config.region}.amazonaws.com/${key}`;
+            resolve(response);
+        }
+        // Failed to upload to S3
+        else {
+            response = null;
+            reject(response);
+        }
+    });
+};
+export default writePresignedPost;

package/dist/esm/aws/s3/writeUrlContents.d.ts

@@ -0,0 +1,10 @@
+type WriteUrlContents = {
+    bucket: string;
+    key: string;
+    url: string;
+};
+/**
+ * Download a file and write to S3.
+ */
+declare const writeUrlContents: ({ bucket, key, url }: WriteUrlContents) => Promise<void>;
+export default writeUrlContents;

package/dist/esm/aws/s3/writeUrlContents.js

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

package/dist/esm/aws/s3cache/getCache.d.ts

@@ -0,0 +1,11 @@
+import { Cache } from "./";
+import { GetKey } from "./getKey";
+type GetCache = GetKey & {
+    bucket: string;
+    cache: Cache;
+};
+/**
+ * Get the stored cache if it exists.
+ */
+declare const getCache: ({ bucket, cache, fileName, folder }: GetCache) => Promise<any>;
+export default getCache;

package/dist/esm/aws/s3cache/getCache.js

@@ -0,0 +1,32 @@
+import { Interval } from "../../date";
+import getKey from "./getKey";
+import readGzip from "../s3/readGzip";
+/**
+ * Get the stored cache if it exists.
+ */
+const getCache = async ({ bucket, cache, fileName, folder }) => {
+    let response = undefined;
+    // Store the cache key
+    const s3CacheKey = getKey({ fileName, folder });
+    // If a cache timeframe is provided and we're not preloading this data
+    if (cache) {
+        // Try to get the cache
+        try {
+            const cached = await readGzip({
+                bucket,
+                key: s3CacheKey,
+                isJson: true,
+            });
+            // Cache exists and is still within our caching timeframe
+            if (undefined !== cached.body && (Interval.FOREVER === cache.timeframe || cached.modified[cache.from][cache.timeframe] < cache.duration)) {
+                response = cached.body;
+            }
+        }
+        catch (error) {
+            // sendError(error, req, res, next);
+            // console.log('s3 error - ', error.message);
+        }
+    }
+    return response;
+};
+export default getCache;

package/dist/esm/aws/s3cache/getKey.d.ts

@@ -0,0 +1,10 @@
+export 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;
+export default getKey;

package/dist/esm/aws/s3cache/getKey.js

@@ -0,0 +1,13 @@
+import trimStart from 'lodash/trimStart';
+import getSha256 from '../../crypto/getSha256';
+import getEnvironment from '../../environment/getEnvironment';
+/**
+ * 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`;
+};
+export default getKey;

package/dist/esm/aws/s3cache/index.d.ts

@@ -0,0 +1,6 @@
+import { DurationComparison, Interval } from "../../date";
+export type Cache = {
+    duration: number;
+    from: DurationComparison;
+    timeframe: Interval;
+};

package/dist/esm/aws/s3cache/index.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/aws/s3cache/saveCache.d.ts

@@ -0,0 +1,10 @@
+type SaveCache = {
+    bucket: string;
+    data: any;
+    key: string;
+};
+/**
+ * Save the cache.
+ */
+declare const saveCache: ({ bucket, data, key }: SaveCache) => Promise<any>;
+export default saveCache;

package/dist/esm/aws/s3cache/saveCache.js

@@ -0,0 +1,12 @@
+import writeGzip from "../s3/writeGzip";
+/**
+ * Save the cache.
+ */
+const saveCache = async ({ bucket, data, key }) => {
+    return await writeGzip({
+        bucket,
+        data,
+        key,
+    });
+};
+export default saveCache;

package/dist/esm/aws/s3cache/updateCache.d.ts

@@ -0,0 +1,10 @@
+import { GetKey } from './getKey';
+type UpdateCache = GetKey & {
+    bucket: string;
+    data: any;
+};
+/**
+ * Delete other caches if present, then save the new file.
+ */
+declare const updateCache: ({ bucket, data, fileName, folder }: UpdateCache) => Promise<void>;
+export default updateCache;

package/dist/esm/aws/s3cache/updateCache.js

@@ -0,0 +1,19 @@
+import deleteFile from '../s3/deleteFile';
+import getKey from './getKey';
+import saveCache from './saveCache';
+/**
+ * Delete other caches if present, then save the new file.
+ */
+const updateCache = async ({ bucket, data, fileName, folder }) => {
+    if (data && null !== data) {
+        const key = getKey({
+            fileName,
+            folder,
+        });
+        // Delete the existing file
+        await deleteFile({ bucket, key });
+        // Save the new file
+        await saveCache({ bucket, data, key });
+    }
+};
+export default updateCache;

package/dist/esm/aws/ses/SimpleEmail.d.ts

@@ -0,0 +1,51 @@
+import BaseClass from "../../class/BaseClass";
+type Constructor = {
+    bcc?: string[];
+    cc?: string[];
+    from?: string;
+    html?: string;
+    subject?: string;
+    to?: string | string[];
+};
+/**
+ * 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;
+    constructor({ bcc, cc, from, html, subject, to }: Constructor);
+    setFrom({ from }: {
+        from: string;
+    }): this;
+    setHtml({ html }: {
+        html: string;
+    }): this;
+    setSubject({ subject }: {
+        subject: string;
+    }): this;
+    pushBcc({ recipient }: {
+        recipient: string | string[];
+    }): this;
+    pushCc({ recipient }: {
+        recipient: string | string[];
+    }): this;
+    pushTo({ recipient }: {
+        recipient: string | string[];
+    }): this;
+    setBcc({ recipient }: {
+        recipient: string | string[];
+    }): this;
+    setCc({ recipient }: {
+        recipient: string | string[];
+    }): this;
+    setTo({ recipient }: {
+        recipient: string | string[];
+    }): this;
+    send(): Promise<boolean>;
+    private _filterRecipients;
+}
+export default SimpleEmail;

package/dist/esm/aws/ses/SimpleEmail.js

@@ -0,0 +1,109 @@
+import uniq from "lodash/uniq";
+import BaseClass from "../../class/BaseClass";
+/**
+ * Class to build and send an AWS SES email.
+ */
+class SimpleEmail extends BaseClass {
+    constructor({ bcc, cc, from, html, subject, to }) {
+        super();
+        this.to = [];
+        this.cc = [];
+        this.bcc = [];
+        if (bcc) {
+            this.setBcc({ recipient: bcc });
+        }
+        if (cc) {
+            this.setCc({ recipient: cc });
+        }
+        if (from) {
+            this.setFrom({ from });
+        }
+        if (html) {
+            this.setHtml({ html });
+        }
+        if (subject) {
+            this.setSubject({ subject });
+        }
+        if (to) {
+            this.setTo({ recipient: to });
+        }
+        return this;
+    }
+    setFrom({ from }) {
+        return this._setValue({ input: from, fields: "from" });
+    }
+    setHtml({ html }) {
+        return this._setValue({ input: html, fields: "html" });
+    }
+    setSubject({ subject }) {
+        return this._setValue({ input: subject, fields: "subject" });
+    }
+    pushBcc({ recipient }) {
+        return this._push({ input: recipient, fields: "bcc" });
+    }
+    pushCc({ recipient }) {
+        return this._push({ input: recipient, fields: "cc" });
+    }
+    pushTo({ recipient }) {
+        return this._push({ input: recipient, fields: "to" });
+    }
+    setBcc({ recipient }) {
+        return this._setArray({ input: recipient, fields: "bcc" });
+    }
+    setCc({ recipient }) {
+        return this._setArray({ input: recipient, fields: "cc" });
+    }
+    setTo({ recipient }) {
+        return this._setArray({ input: recipient, fields: "to" });
+    }
+    async send() {
+        const { SendEmailCommand } = require("@aws-sdk/client-ses");
+        let response;
+        // https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/ses-examples-sending-email.html
+        const params = {
+            Destination: {
+                BccAddresses: this._filterRecipients({ field: "bcc" }),
+                CcAddresses: this._filterRecipients({ field: "cc" }),
+                ToAddresses: this._filterRecipients({ field: "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,
+        };
+        const command = new SendEmailCommand(params);
+        try {
+            response = await global.awsSesClient.send(command);
+        }
+        catch (exception) {
+            response = exception;
+        }
+        return response;
+    }
+    _filterRecipients({ field }) {
+        // Remove all undefined and null values
+        let response = this[field].filter(recipient => recipient && null !== recipient);
+        // Clean all the values
+        response = response.map(recipient => recipient.toLowerCase()
+            .trim());
+        // Remove all empty values
+        response = response.filter(recipient => "" !== recipient);
+        // Return only unique values
+        response = uniq(response);
+        return response;
+    }
+}
+export default SimpleEmail;

package/dist/esm/aws/ses/initClient.d.ts

@@ -0,0 +1,10 @@
+import { Config } from '../getConfig';
+type InitClient = {
+    config: Config;
+};
+/**
+ * Shorthand function to get the Lambda Client.
+ * Library: @aws-sdk/client-ses
+ */
+declare const initClient: ({ config }: InitClient) => void;
+export default initClient;

package/dist/esm/aws/ses/initClient.js

@@ -0,0 +1,14 @@
+import getConfig from '../getConfig';
+global.awsSesClient = null;
+/**
+ * Shorthand function to get the Lambda Client.
+ * Library: @aws-sdk/client-ses
+ */
+const initClient = ({ config }) => {
+    if (!global.awsSesClient) {
+        const { SESClient } = require('@aws-sdk/client-ses');
+        const formattedConfig = getConfig({ config });
+        global.awsSesClient = new SESClient(formattedConfig);
+    }
+};
+export default initClient;

package/dist/esm/aws/sqs/addToQueue.d.ts

@@ -0,0 +1,27 @@
+export type AddedResponse = {
+    '$metadata': {
+        httpStatusCode: number;
+        requestId: string;
+        extendedRequestId: undefined | string;
+        cfId: undefined | string;
+        attempts: number;
+        totalRetryDelay: number;
+    };
+    MD5OfMessageBody: string;
+    MD5OfMessageAttributes: undefined | string;
+    MD5OfMessageSystemAttributes: undefined | string;
+    MessageId: string;
+    SequenceNumber: string;
+};
+type AddToQueue = {
+    data: any;
+    dedupeId: string;
+    groupId?: string;
+    queueId?: string;
+    queueUrl: string;
+};
+/**
+ * https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sqs-examples-send-receive-messages.html
+ */
+declare const addToQueue: ({ data, dedupeId, groupId, queueId, queueUrl }: AddToQueue) => Promise<AddedResponse>;
+export default addToQueue;

package/dist/esm/aws/sqs/addToQueue.js

@@ -0,0 +1,24 @@
+/**
+ * https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sqs-examples-send-receive-messages.html
+ */
+const addToQueue = async ({ data, dedupeId, groupId, queueId, queueUrl }) => {
+    const { SendMessageCommand } = require('@aws-sdk/client-sqs');
+    let params = {
+        MessageBody: JSON.stringify({
+            queueId,
+            data,
+        }),
+        QueueUrl: queueUrl,
+    };
+    // Required for FIFO
+    if (undefined !== dedupeId) {
+        params["MessageDeduplicationId"] = dedupeId;
+    }
+    // Required for FIFO
+    if (undefined !== groupId) {
+        params["MessageGroupId"] = dedupeId;
+    }
+    const sendData = await global.awsSqsClient.send(new SendMessageCommand(params));
+    return sendData;
+};
+export default addToQueue;

package/dist/esm/aws/sqs/deleteFromQueue.d.ts

@@ -0,0 +1,10 @@
+import { AddedResponse } from './addToQueue';
+type DeleteFromQueue = {
+    queueUrl: string;
+    recipientHandle: string;
+};
+/**
+ * Delete a message from a queue.
+ */
+declare const deleteFromQueue: ({ queueUrl, recipientHandle }: DeleteFromQueue) => Promise<AddedResponse>;
+export default deleteFromQueue;

package/dist/esm/aws/sqs/deleteFromQueue.js

@@ -0,0 +1,13 @@
+/**
+ * Delete a message from a queue.
+ */
+const deleteFromQueue = async ({ queueUrl, recipientHandle }) => {
+    const { DeleteMessageCommand } = require('@aws-sdk/client-sqs');
+    const params = {
+        QueueUrl: queueUrl,
+        ReceiptHandle: recipientHandle,
+    };
+    const sendData = await global.awsSqsClient.send(new DeleteMessageCommand(params));
+    return sendData;
+};
+export default deleteFromQueue;

package/dist/esm/aws/sqs/initClient.d.ts

@@ -0,0 +1,10 @@
+import { Config } from '../getConfig';
+type InitClient = {
+    config: Config;
+};
+/**
+ * Shorthand function to get the Lambda Client.
+ * Library: @aws-sdk/client-lambda
+ */
+declare const initClient: ({ config }: InitClient) => void;
+export default initClient;

package/dist/esm/aws/sqs/initClient.js

@@ -0,0 +1,14 @@
+import getConfig from '../getConfig';
+global.awsSqsClient = null;
+/**
+ * Shorthand function to get the Lambda Client.
+ * Library: @aws-sdk/client-lambda
+ */
+const initClient = ({ config }) => {
+    if (!global.awsLambdaClient) {
+        const { SQSClient } = require('@aws-sdk/client-sqs');
+        const formattedConfig = getConfig({ config });
+        global.awsSqsClient = new SQSClient(formattedConfig);
+    }
+};
+export default initClient;

package/dist/esm/aws/sqs/isEventSqs.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/aws/sqs/isEventSqs.js

@@ -0,0 +1,12 @@
+/**
+ * Check to see if the request is an SQS queued event,
+ */
+const isEventSqs = ({ event }) => {
+    let response = false;
+    if (undefined !== event['Records']) {
+        for (let i = 0; i < event['Records'].length; i++) {
+        }
+    }
+    return response;
+};
+export {};

package/dist/esm/aws/ssm/getParameter.d.ts

@@ -0,0 +1,10 @@
+type GetParameter = {
+    name: string;
+    withDecryption?: boolean;
+    isJson?: boolean;
+};
+/**
+ * Get a parameter and decryption if necessary (secure string)
+ */
+declare const getParameter: ({ name, withDecryption, isJson }: GetParameter) => Promise<any>;
+export default getParameter;