@8ms/helpers 1.40.6 → 1.40.10

package/aws/s3/listFiles.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getFolder_1 = __importDefault(require("../../string/getFolder"));
+/**
+ * List the files in the given bucket and option folder
+ */
+const listFiles = async ({ bucket, folder = '' }) => {
+    const cleanFolder = (0, getFolder_1.default)({ input: folder });
+    let response = [];
+    let valid = [];
+    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['Contents']) {
+        // Return an array of files
+        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;
+};
+exports.default = listFiles;

package/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/aws/s3/listFilesIteratively.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const listFolders_1 = __importDefault(require("./listFolders"));
+const listFiles_1 = __importDefault(require("./listFiles"));
+/**
+ * Sub function
+ */
+const iterateFolders = async (props) => {
+    let response = [];
+    const folders = await (0, listFolders_1.default)({
+        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 (0, listFiles_1.default)({
+            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;
+};
+exports.default = listFilesIteratively;

package/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/aws/s3/listFolders.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getFolder_1 = __importDefault(require("../../string/getFolder"));
+/**
+ * List the files in the given bucket and option folder.
+ */
+const listFolders = async ({ bucket, folder }) => {
+    const cleanFolder = (0, getFolder_1.default)({ 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;
+};
+exports.default = listFolders;

package/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/aws/s3/moveFile.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const copyFile_1 = __importDefault(require("./copyFile"));
+const deleteFile_1 = __importDefault(require("./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 (0, copyFile_1.default)({
+        from,
+        to,
+    });
+    await (0, deleteFile_1.default)({
+        bucket: from.bucket,
+        key: from.key,
+    });
+};
+exports.default = moveFile;

package/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/aws/s3/readBrotli.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getBrotliDecompressed_1 = __importDefault(require("../../util/getBrotliDecompressed"));
+const readFile_1 = __importDefault(require("./readFile"));
+/**
+ * Read a file from S3 and return either null, the content or JSON decoded.
+ */
+const readBrotli = async ({ bucket, key, isJson }) => {
+    let response = await (0, readFile_1.default)({
+        bucket,
+        key,
+        isJson: false
+    });
+    // Cache exists and is still within our caching timeframe
+    if (undefined !== response.body) {
+        response.body = await (0, getBrotliDecompressed_1.default)({
+            input: response.body,
+        });
+        if (false !== isJson) {
+            response.body = JSON.parse(response.body);
+        }
+    }
+    return response;
+};
+exports.default = readBrotli;

package/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/aws/s3/readBuffer.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isResponse200_1 = __importDefault(require("../isResponse200"));
+const readFile_1 = require("./readFile");
+/**
+ * Similar function to reading the S3 file, but instead of a text file return a buffer.
+ */
+const readBuffer = async ({ bucket, key }) => {
+    let response = {
+        ...readFile_1.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 ((0, isResponse200_1.default)({ 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;
+};
+exports.default = readBuffer;

package/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/aws/s3/readFile.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFileDefault = void 0;
+const date_fns_1 = require("date-fns");
+const date_fns_2 = require("date-fns");
+const date_fns_3 = require("date-fns");
+const date_fns_4 = require("date-fns");
+const date_fns_5 = require("date-fns");
+const date_fns_6 = require("date-fns");
+const date_fns_7 = require("date-fns");
+const getToday_1 = __importDefault(require("../../date/getToday"));
+const getDate_1 = __importDefault(require("../../date/getDate"));
+const getStringFromStream_1 = __importDefault(require("../../string/getStringFromStream"));
+const isResponse200_1 = __importDefault(require("../isResponse200"));
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+const isFileExists_1 = __importDefault(require("./isFileExists"));
+const date_1 = require("../../date");
+exports.readFileDefault = {
+    body: undefined,
+    now: undefined,
+    modified: {
+        unix: null,
+        [date_1.DurationComparison.VS_NOW]: {
+            months: 0,
+            days: 0,
+            hours: 0,
+            minutes: 0,
+        },
+        [date_1.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 = (0, cloneDeep_1.default)(exports.readFileDefault);
+    const today = (0, getToday_1.default)({
+        setMidnight: false
+    });
+    response.now = (0, date_fns_7.getUnixTime)(today);
+    const doesFileExist = await (0, isFileExists_1.default)({
+        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 ((0, isResponse200_1.default)({ apiResponse })) {
+            let now = today;
+            let modified = (0, getDate_1.default)({ input: apiResponse.LastModified, setMidnight: false });
+            // Convert the date to unix
+            response.modified.unix = (0, date_fns_7.getUnixTime)(modified);
+            // Compare now to unix
+            response.modified[date_1.DurationComparison.VS_NOW].months = (0, date_fns_4.differenceInMonths)(now, modified);
+            response.modified[date_1.DurationComparison.VS_NOW].days = (0, date_fns_1.differenceInDays)(now, modified);
+            response.modified[date_1.DurationComparison.VS_NOW].hours = (0, date_fns_2.differenceInHours)(now, modified);
+            response.modified[date_1.DurationComparison.VS_NOW].minutes = (0, date_fns_3.differenceInMinutes)(now, modified);
+            // Compare now to midnight
+            response.modified[date_1.DurationComparison.VS_MIDNIGHT].hours = (0, date_fns_5.getHours)(now);
+            response.modified[date_1.DurationComparison.VS_MIDNIGHT].minutes = (0, date_fns_6.getMinutes)(now);
+            // Convert stream into a string
+            response.body = await (0, getStringFromStream_1.default)({
+                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;
+};
+exports.default = readFile;

package/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/aws/s3/readGzip.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const readFile_1 = __importDefault(require("./readFile"));
+const getGzipDecompressed_1 = __importDefault(require("../../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 (0, readFile_1.default)({
+        bucket,
+        key,
+        isJson: false
+    });
+    // Cache exists and is still within our caching timeframe
+    if (undefined !== response.body) {
+        response.body = await (0, getGzipDecompressed_1.default)({
+            input: response.body,
+        });
+        if (false !== isJson) {
+            response.body = JSON.parse(response.body);
+        }
+    }
+    return response;
+};
+exports.default = readGzip;

package/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/aws/s3/writeBrotli.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getBrotliCompressed_1 = __importDefault(require("../../util/getBrotliCompressed"));
+const writeFile_1 = __importDefault(require("./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 (0, getBrotliCompressed_1.default)({
+        input: finalData,
+    });
+    const apiResponse = await (0, writeFile_1.default)({
+        bucket,
+        data: brotliData,
+        key,
+        ...options,
+    });
+    return apiResponse;
+};
+exports.default = writeBrotli;

package/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/aws/s3/writeFile.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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;
+};
+exports.default = writeFile;

package/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/aws/s3/writeGzip.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getGzipCompressed_1 = __importDefault(require("../../util/getGzipCompressed"));
+const writeFile_1 = __importDefault(require("./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 (0, getGzipCompressed_1.default)({
+        input: finalData,
+    });
+    const apiResponse = await (0, writeFile_1.default)({
+        bucket,
+        data: brotliData,
+        key,
+        ...options,
+    });
+    return apiResponse;
+};
+exports.default = writeGzip;

package/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/aws/s3/writePresignedPost.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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);
+        }
+    });
+};
+exports.default = writePresignedPost;

package/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/aws/s3/writeUrlContents.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ky_1 = __importDefault(require("ky"));
+const writeFile_1 = __importDefault(require("./writeFile"));
+/**
+ * Download a file and write to S3.
+ */
+const writeUrlContents = async ({ bucket, key, url }) => {
+    const response = await ky_1.default.get(url);
+    const arrayBuffer = await response.arrayBuffer();
+    const data = Buffer.from(arrayBuffer);
+    await (0, writeFile_1.default)({
+        bucket,
+        data,
+        key,
+        ContentType: response.headers.get("content-type"),
+        ContentLength: response.headers.get("content-length"),
+    });
+};
+exports.default = writeUrlContents;

package/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/aws/s3cache/getCache.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const date_1 = require("../../date");
+const getKey_1 = __importDefault(require("./getKey"));
+const readGzip_1 = __importDefault(require("../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 = (0, getKey_1.default)({ 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 (0, readGzip_1.default)({
+                bucket,
+                key: s3CacheKey,
+                isJson: true,
+            });
+            // Cache exists and is still within our caching timeframe
+            if (undefined !== cached.body && (date_1.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;
+};
+exports.default = getCache;