@8ms/helpers 1.41.0 → 1.42.0

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

@@ -0,0 +1,9 @@
+type ListFilesIteratively = {
+    bucket: string;
+    folder: string;
+};
+/**
+ * Fetch all the files within a given directory recursively
+ */
+declare const listFilesIteratively: (props: ListFilesIteratively) => Promise<string[]>;
+export default listFilesIteratively;

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

@@ -0,0 +1,39 @@
+import listFolders from "./listFolders";
+import listFiles from "./listFiles";
+/**
+ * Sub function
+ */
+const iterateFolders = async (props) => {
+    let response = [];
+    const folders = await listFolders({
+        bucket: props.bucket,
+        folder: props.folder,
+    });
+    for (let i = 0; i < folders.length; i++) {
+        const subFolderFiles = await iterateFolders({
+            bucket: props.bucket,
+            folder: `${props.folder}/${folders[i]}`,
+        });
+        const files = await listFiles({
+            bucket: props.bucket,
+            folder: `${props.folder}/${folders[i]}`,
+        });
+        response = [
+            ...response,
+            ...files,
+            ...subFolderFiles,
+        ];
+    }
+    return response;
+};
+/**
+ * Fetch all the files within a given directory recursively
+ */
+const listFilesIteratively = async (props) => {
+    const response = await iterateFolders({
+        bucket: props.bucket,
+        folder: props.folder,
+    });
+    return response;
+};
+export default listFilesIteratively;

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

@@ -0,0 +1,9 @@
+type ListFolders = {
+    bucket: string;
+    folder: string;
+};
+/**
+ * List the files in the given bucket and option folder.
+ */
+declare const listFolders: ({ bucket, folder }: ListFolders) => Promise<string[]>;
+export default listFolders;

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

@@ -0,0 +1,27 @@
+import getFolder from '../../string/getFolder';
+/**
+ * List the files in the given bucket and option folder.
+ */
+const listFolders = async ({ bucket, folder }) => {
+    const cleanFolder = getFolder({ input: folder });
+    let response = [];
+    const { ListObjectsV2Command } = require('@aws-sdk/client-s3');
+    const apiResponse = await global.awsS3Client.send(new ListObjectsV2Command({
+        Bucket: bucket,
+        Delimiter: '/',
+        Prefix: ('' === cleanFolder ? '' : cleanFolder + '/'),
+    }));
+    // Ensure the data exists
+    if (undefined !== apiResponse['CommonPrefixes']) {
+        // Return an array of folders removing the trailing folder
+        response = apiResponse['CommonPrefixes'].map(prefix => {
+            // Remove the trailing slash then split by slash
+            const fileFolders = prefix.Prefix.slice(0, -1)
+                .split('/');
+            // Return the last folder without a trailing slash
+            return fileFolders[fileFolders.length - 1];
+        });
+    }
+    return response;
+};
+export default listFolders;

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

@@ -0,0 +1,10 @@
+import { File } from './copyFile';
+type MoveFiles = {
+    from: File;
+    to: File;
+};
+/**
+ * It's not possible to just move or rename a file, you must copy then delete the old file.
+ */
+declare const moveFile: ({ from, to }: MoveFiles) => Promise<void>;
+export default moveFile;

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

@@ -0,0 +1,16 @@
+import copyFile from './copyFile';
+import deleteFile from './deleteFile';
+/**
+ * It's not possible to just move or rename a file, you must copy then delete the old file.
+ */
+const moveFile = async ({ from, to }) => {
+    await copyFile({
+        from,
+        to,
+    });
+    await deleteFile({
+        bucket: from.bucket,
+        key: from.key,
+    });
+};
+export default moveFile;

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

@@ -0,0 +1,11 @@
+import { ReadFileResponse } from "./readFile";
+type ReadBrotli = {
+    bucket: string;
+    key: string;
+    isJson?: boolean;
+};
+/**
+ * Read a file from S3 and return either null, the content or JSON decoded.
+ */
+declare const readBrotli: ({ bucket, key, isJson }: ReadBrotli) => Promise<ReadFileResponse>;
+export default readBrotli;

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

@@ -0,0 +1,23 @@
+import getBrotliDecompressed from "../../util/getBrotliDecompressed";
+import readFile from "./readFile";
+/**
+ * Read a file from S3 and return either null, the content or JSON decoded.
+ */
+const readBrotli = async ({ bucket, key, isJson }) => {
+    let response = await readFile({
+        bucket,
+        key,
+        isJson: false
+    });
+    // Cache exists and is still within our caching timeframe
+    if (undefined !== response.body) {
+        response.body = await getBrotliDecompressed({
+            input: response.body,
+        });
+        if (false !== isJson) {
+            response.body = JSON.parse(response.body);
+        }
+    }
+    return response;
+};
+export default readBrotli;

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

@@ -0,0 +1,13 @@
+import { Modified } from "./readFile";
+export type ReadBufferResponse = Modified & {
+    buffer: any;
+};
+type ReadBuffer = {
+    bucket: string;
+    key: string;
+};
+/**
+ * Similar function to reading the S3 file, but instead of a text file return a buffer.
+ */
+declare const readBuffer: ({ bucket, key }: ReadBuffer) => Promise<ReadBufferResponse>;
+export default readBuffer;

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

@@ -0,0 +1,34 @@
+import isResponse200 from "../isResponse200";
+import { readFileDefault } from "./readFile";
+/**
+ * Similar function to reading the S3 file, but instead of a text file return a buffer.
+ */
+const readBuffer = async ({ bucket, key }) => {
+    let response = {
+        ...readFileDefault,
+        buffer: undefined,
+    };
+    const { GetObjectCommand } = require("@aws-sdk/client-s3");
+    const apiResponse = await global.awsS3Client.send(new GetObjectCommand({
+        Bucket: bucket,
+        Key: key,
+    }));
+    // console.log('apiResponse', apiResponse);
+    if (isResponse200({ apiResponse })) {
+        const chunks = [];
+        // Store the response
+        response.buffer = await new Promise((resolve, reject) => {
+            // @ts-ignore
+            apiResponse.Body.on("data", (chunk) => chunks.push(chunk));
+            // @ts-ignore
+            apiResponse.Body.on("error", (err) => reject(err));
+            // @ts-ignore
+            apiResponse.Body.on("end", () => resolve(Buffer.concat(chunks)));
+        });
+    }
+    else {
+        throw new Error("Error reading file.");
+    }
+    return response;
+};
+export default readBuffer;

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

@@ -0,0 +1,31 @@
+import { DurationComparison } from "../../date";
+export type Modified = {
+    now: number;
+    modified: {
+        unix: null | number;
+        [DurationComparison.VS_NOW]: {
+            months: number;
+            days: number;
+            hours: number;
+            minutes: number;
+        };
+        [DurationComparison.VS_MIDNIGHT]: {
+            hours: number;
+            minutes: number;
+        };
+    };
+};
+export type ReadFileResponse = Modified & {
+    body: any;
+};
+export declare const readFileDefault: ReadFileResponse;
+type ReadFile = {
+    bucket: string;
+    key: string;
+    isJson?: boolean;
+};
+/**
+ * Read a file from S3 and return either null, the content or JSON decoded.
+ */
+declare const readFile: ({ bucket, key, isJson }: ReadFile) => Promise<ReadFileResponse>;
+export default readFile;

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

@@ -0,0 +1,77 @@
+import { differenceInDays } from "date-fns";
+import { differenceInHours } from "date-fns";
+import { differenceInMinutes } from "date-fns";
+import { differenceInMonths } from "date-fns";
+import { getHours } from "date-fns";
+import { getMinutes } from "date-fns";
+import { getUnixTime } from "date-fns";
+import getToday from "../../date/getToday";
+import getDate from "../../date/getDate";
+import getStringFromStream from "../../string/getStringFromStream";
+import isResponse200 from "../isResponse200";
+import cloneDeep from "lodash/cloneDeep";
+import isFileExists from "./isFileExists";
+import { DurationComparison } from "../../date";
+export const readFileDefault = {
+    body: undefined,
+    now: undefined,
+    modified: {
+        unix: null,
+        [DurationComparison.VS_NOW]: {
+            months: 0,
+            days: 0,
+            hours: 0,
+            minutes: 0,
+        },
+        [DurationComparison.VS_MIDNIGHT]: {
+            hours: 0,
+            minutes: 0,
+        },
+    },
+};
+/**
+ * Read a file from S3 and return either null, the content or JSON decoded.
+ */
+const readFile = async ({ bucket, key, isJson }) => {
+    let response = cloneDeep(readFileDefault);
+    const today = getToday({
+        setMidnight: false
+    });
+    response.now = getUnixTime(today);
+    const doesFileExist = await isFileExists({
+        bucket,
+        key
+    });
+    // Only fetch the file if it exists
+    if (doesFileExist) {
+        const { GetObjectCommand } = require("@aws-sdk/client-s3");
+        const apiResponse = await global.awsS3Client.send(new GetObjectCommand({
+            Bucket: bucket,
+            Key: key,
+        }));
+        if (isResponse200({ apiResponse })) {
+            let now = today;
+            let modified = getDate({ input: apiResponse.LastModified, setMidnight: false });
+            // Convert the date to unix
+            response.modified.unix = getUnixTime(modified);
+            // Compare now to unix
+            response.modified[DurationComparison.VS_NOW].months = differenceInMonths(now, modified);
+            response.modified[DurationComparison.VS_NOW].days = differenceInDays(now, modified);
+            response.modified[DurationComparison.VS_NOW].hours = differenceInHours(now, modified);
+            response.modified[DurationComparison.VS_NOW].minutes = differenceInMinutes(now, modified);
+            // Compare now to midnight
+            response.modified[DurationComparison.VS_MIDNIGHT].hours = getHours(now);
+            response.modified[DurationComparison.VS_MIDNIGHT].minutes = getMinutes(now);
+            // Convert stream into a string
+            response.body = await getStringFromStream({
+                stream: apiResponse.Body
+            });
+            // If we need to return JSON, parse it. On error return undefined
+            if (false !== isJson) {
+                response.body = JSON.parse(response.body) || undefined;
+            }
+        }
+    }
+    return response;
+};
+export default readFile;

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

@@ -0,0 +1,11 @@
+import { ReadFileResponse } from "./readFile";
+type ReadBrotli = {
+    bucket: string;
+    key: string;
+    isJson?: boolean;
+};
+/**
+ * Read a file from S3 and return either null, the content or JSON decoded.
+ */
+declare const readGzip: ({ bucket, key, isJson }: ReadBrotli) => Promise<ReadFileResponse>;
+export default readGzip;

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

@@ -0,0 +1,23 @@
+import readFile from "./readFile";
+import getGzipDecompressed from "../../util/getGzipDecompressed";
+/**
+ * Read a file from S3 and return either null, the content or JSON decoded.
+ */
+const readGzip = async ({ bucket, key, isJson }) => {
+    let response = await readFile({
+        bucket,
+        key,
+        isJson: false
+    });
+    // Cache exists and is still within our caching timeframe
+    if (undefined !== response.body) {
+        response.body = await getGzipDecompressed({
+            input: response.body,
+        });
+        if (false !== isJson) {
+            response.body = JSON.parse(response.body);
+        }
+    }
+    return response;
+};
+export default readGzip;

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;