@8ms/helpers 1.40.6 → 1.40.9

package/aws/ecs/runTask.d.ts

@@ -0,0 +1,16 @@
+import { LaunchType, NetworkConfiguration, TaskOverride } from "@aws-sdk/client-ecs";
+type RunTask = {
+    cluster?: string;
+    count?: number;
+    launchType?: LaunchType;
+    networkConfiguration?: NetworkConfiguration;
+    overrides?: TaskOverride;
+    taskDefinition?: string;
+};
+/**
+ * Initialise and run a task
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ecs/command/RunTaskCommand/
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ecs/Interface/RunTaskCommandInput/
+ */
+export declare const runTask: (props: RunTask) => Promise<boolean>;
+export {};

package/aws/ecs/runTask.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTask = void 0;
+const isResponse200_1 = __importDefault(require("../isResponse200"));
+/**
+ * Initialise and run a task
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ecs/command/RunTaskCommand/
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ecs/Interface/RunTaskCommandInput/
+ */
+const runTask = async (props) => {
+    let response = false;
+    const { RunTaskCommand } = require("@aws-sdk/client-ecs");
+    const runtTaskCommand = new RunTaskCommand({
+        cluster: props?.cluster,
+        launchType: props?.launchType,
+        networkConfiguration: props?.networkConfiguration,
+        overrides: props?.overrides,
+        taskDefinition: props?.taskDefinition,
+    });
+    const apiResponse = await global.awsEcsClient.send(runtTaskCommand);
+    // console.log("runTaskCommandResponse", apiResponse);
+    if ((0, isResponse200_1.default)({ apiResponse })) {
+        response = apiResponse;
+    }
+    return response;
+};
+exports.runTask = runTask;

package/aws/getConfig.d.ts

@@ -0,0 +1,13 @@
+export type Config = {
+    accessKeyId: string;
+    region: string;
+    secretAccessKey: string;
+};
+/**
+ * The config must be in a specific structure, if the properties aren't defined don't specify them as they could be inferred (e.g. Lambda).
+ */
+declare const getConfig: ({ config, isAthenaExpress }: {
+    config: Config;
+    isAthenaExpress?: boolean;
+}) => object;
+export default getConfig;

package/aws/getConfig.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * The config must be in a specific structure, if the properties aren't defined don't specify them as they could be inferred (e.g. Lambda).
+ */
+const getConfig = ({ config, isAthenaExpress }) => {
+    let response = {
+        region: config.region,
+    };
+    // Set the key id and access key if its defined (not required for AWS SAM)
+    if ('' !== config.accessKeyId && '' !== config.secretAccessKey) {
+        // Athena is a flat structure
+        if (true === isAthenaExpress) {
+            response['accessKeyId'] = config.accessKeyId;
+            response['secretAccessKey'] = config.secretAccessKey;
+        }
+        // AWS services are under credentials
+        else {
+            response['credentials'] = {
+                accessKeyId: config.accessKeyId,
+                secretAccessKey: config.secretAccessKey,
+            };
+        }
+    }
+    return response;
+};
+exports.default = getConfig;

package/aws/glue/initClient.d.ts

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

package/aws/glue/initClient.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 getConfig_1 = __importDefault(require("../getConfig"));
+global.awsGlueClient = null;
+/**
+ * Shorthand function to get the Glue Client.
+ * Library: @aws-sdk/client-glue
+ */
+const initClient = (props) => {
+    if (!global.awsGlueClient) {
+        const { GlueClient } = require('@aws-sdk/client-glue');
+        const formattedConfig = (0, getConfig_1.default)({
+            config: props.config
+        });
+        global.awsGlueClient = new GlueClient(formattedConfig);
+    }
+};
+exports.default = initClient;

package/aws/glue/invoke.d.ts

@@ -0,0 +1,9 @@
+type Invoke = {
+    crawler: string;
+};
+/**
+ * Invoke an AWS Glue Crawler by passing in the name of the Crawler.
+ * Library: @aws-sdk/client-glue
+ */
+declare const invoke: (props: Invoke) => Promise<boolean>;
+export default invoke;

package/aws/glue/invoke.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 isResponse200_1 = __importDefault(require("../isResponse200"));
+/**
+ * Invoke an AWS Glue Crawler by passing in the name of the Crawler.
+ * Library: @aws-sdk/client-glue
+ */
+const invoke = async (props) => {
+    const { StartCrawlerCommand } = require('@aws-sdk/client-glue');
+    const command = new StartCrawlerCommand({
+        Name: props.crawler,
+    });
+    // Fire the event but don't wait for it to complete
+    const apiResponse = await global.awsGlueClient.send(command);
+    // Success
+    return (0, isResponse200_1.default)({
+        apiResponse
+    });
+};
+exports.default = invoke;

package/aws/isResponse200.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Was the API response a 200?
+ */
+declare const isResponse200: ({ apiResponse }: {
+    apiResponse: any;
+}) => boolean;
+export default isResponse200;

package/aws/isResponse200.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const defaultTo_1 = __importDefault(require("../util/defaultTo"));
+/**
+ * Was the API response a 200?
+ */
+const isResponse200 = ({ apiResponse }) => {
+    let response = false;
+    const responseCode = (0, defaultTo_1.default)({
+        defaultValue: 0,
+        instance: apiResponse,
+        keys: ['$metadata', 'httpStatusCode'],
+    });
+    if (200 === responseCode) {
+        response = true;
+    }
+    return response;
+};
+exports.default = isResponse200;

package/aws/lambda/getHandlerPath.d.ts

@@ -0,0 +1,5 @@
+type GetHandlerPath = {
+    input: string;
+};
+declare const getHandlerPath: (props: GetHandlerPath) => string;
+export default getHandlerPath;

package/aws/lambda/getHandlerPath.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getHandlerPath = (props) => {
+    return `${props.input.split(process.cwd())[1].substring(1)
+        .replace(/\\/g, '/')}`;
+};
+exports.default = getHandlerPath;

package/aws/lambda/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: (props: InitClient) => void;
+export default initClient;

package/aws/lambda/initClient.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 getConfig_1 = __importDefault(require("../getConfig"));
+global.awsLambdaClient = null;
+/**
+ * Shorthand function to get the Lambda Client.
+ * Library: @aws-sdk/client-lambda
+ */
+const initClient = (props) => {
+    if (!global.awsLambdaClient) {
+        const { LambdaClient } = require('@aws-sdk/client-lambda');
+        const formattedConfig = (0, getConfig_1.default)({
+            config: props.config
+        });
+        global.awsLambdaClient = new LambdaClient(formattedConfig);
+    }
+};
+exports.default = initClient;

package/aws/lambda/invoke.d.ts

@@ -0,0 +1,13 @@
+type Invoke = {
+    awaitResponse?: boolean;
+    functionName: string;
+    isJson?: boolean;
+    payload?: object;
+};
+/**
+ * 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
+ */
+declare const invoke: (props: Invoke) => Promise<any>;
+export default invoke;

package/aws/lambda/invoke.js

@@ -0,0 +1,61 @@
+"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 ApiResponse_1 = __importDefault(require("../../api/ApiResponse"));
+/**
+ * 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
+ */
+const invoke = async (props) => {
+    let response = false;
+    const params = {
+        FunctionName: props.functionName,
+        InvocationType: true === props.awaitResponse ? 'RequestResponse' : 'Event',
+    };
+    // Payload is defined add to parameters
+    if (undefined !== props.payload) {
+        params['Payload'] = new Uint8Array(Buffer.from(JSON.stringify(props.payload)));
+    }
+    // Create the Lambda Command
+    const { InvokeCommand } = require('@aws-sdk/client-lambda');
+    const command = new InvokeCommand(params);
+    // Fire the event but don't wait for it to complete
+    const apiResponse = await global.awsLambdaClient.send(command);
+    // Success
+    if ((0, isResponse200_1.default)({ apiResponse })) {
+        // Return the data
+        if (props.awaitResponse && undefined !== apiResponse.Payload) {
+            const asciiDecoder = new TextDecoder('ascii');
+            response = asciiDecoder.decode(apiResponse.Payload);
+            // Decode string as JSON object
+            if (true === props.isJson) {
+                response = JSON.parse(response);
+                // If it's still a string, double decode it
+                if ('string' === typeof response) {
+                    response = JSON.parse(response);
+                }
+                // If the response is a ApiResponse compatible
+                if (undefined !== response &&
+                    // @ts-ignore
+                    undefined !== response?.error &&
+                    // @ts-ignore
+                    undefined !== response?.state) {
+                    response = (new ApiResponse_1.default()).fromJson({
+                        // @ts-ignore
+                        input: response
+                    });
+                }
+            }
+        }
+        // Success but not waiting for response
+        else {
+            response = true;
+        }
+    }
+    return response;
+};
+exports.default = invoke;

package/aws/s3/copyFile.d.ts

@@ -0,0 +1,13 @@
+export type File = {
+    bucket: string;
+    key: string;
+};
+type CopyFile = {
+    from: File;
+    to: File;
+};
+/**
+ * Copy a file from one bucket/path to another bucket/path.
+ */
+declare const copyFile: ({ from, to }: CopyFile) => Promise<void>;
+export default copyFile;

package/aws/s3/copyFile.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Copy a file from one bucket/path to another bucket/path.
+ */
+const copyFile = async ({ from, to }) => {
+    const { CopyObjectCommand } = require('@aws-sdk/client-s3');
+    await global.awsS3Client.send(new CopyObjectCommand({
+        Bucket: to.bucket,
+        CopySource: encodeURIComponent(`${from.bucket}/${from.key}`),
+        Key: to.key,
+    }));
+};
+exports.default = copyFile;

package/aws/s3/deleteFile.d.ts

@@ -0,0 +1,9 @@
+type DeleteFile = {
+    bucket: string;
+    key: string;
+};
+/**
+ * Delete a single file.
+ */
+declare const deleteFile: ({ bucket, key }: DeleteFile) => Promise<void>;
+export default deleteFile;

package/aws/s3/deleteFile.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Delete a single file.
+ */
+const deleteFile = async ({ bucket, key }) => {
+    const { DeleteObjectCommand } = require('@aws-sdk/client-s3');
+    await global.awsS3Client.send(new DeleteObjectCommand({
+        Bucket: bucket,
+        Key: key,
+    }));
+};
+exports.default = deleteFile;

package/aws/s3/deleteFiles.d.ts

@@ -0,0 +1,9 @@
+type DeleteFiles = {
+    bucket: string;
+    keys: string[];
+};
+/**
+ * Delete multiple files.
+ */
+declare const deleteFiles: ({ bucket, keys }: DeleteFiles) => Promise<void>;
+export default deleteFiles;

package/aws/s3/deleteFiles.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Delete multiple files.
+ */
+const deleteFiles = async ({ bucket, keys }) => {
+    const { DeleteObjectsCommand } = require('@aws-sdk/client-s3');
+    await global.awsS3Client.send(new DeleteObjectsCommand({
+        Bucket: bucket,
+        Delete: {
+            Objects: keys.map(key => ({
+                Key: key,
+            })),
+        },
+    }));
+};
+exports.default = deleteFiles;

package/aws/s3/deleteFolder.d.ts

@@ -0,0 +1,9 @@
+type DeleteFolder = {
+    bucket: string;
+    folder: string;
+};
+/**
+ * Iteratively delete all the files within a directory and delete the directory.
+ */
+declare const deleteFolder: ({ bucket, folder }: DeleteFolder) => Promise<void>;
+export default deleteFolder;

package/aws/s3/deleteFolder.js

@@ -0,0 +1,36 @@
+"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"));
+/**
+ * Iteratively delete all the files within a directory and delete the directory.
+ */
+const deleteFolder = async ({ bucket, folder }) => {
+    const cleanFolder = (0, getFolder_1.default)({ input: folder });
+    const { ListObjectsV2Command, DeleteObjectsCommand } = require('@aws-sdk/client-s3');
+    // Get a list of all files to be deleted
+    const apiResponse = await global.awsS3Client.send(new ListObjectsV2Command({
+        Bucket: bucket,
+        Prefix: ('' === cleanFolder ? '' : cleanFolder + '/'),
+    }));
+    // No files to be deleted
+    if (apiResponse.Contents.length === 0) {
+        return;
+    }
+    // Map each of the files
+    const keys = apiResponse.Contents.map(file => ({ Key: file.Key }));
+    // Delete the files
+    await global.awsS3Client.send(new DeleteObjectsCommand({
+        Bucket: bucket,
+        Delete: {
+            Objects: keys,
+        },
+    }));
+    // If we didn't get all files, run it again
+    if (apiResponse.IsTruncated) {
+        await deleteFolder({ bucket, folder });
+    }
+};
+exports.default = deleteFolder;

package/aws/s3/getGlueJson.d.ts

@@ -0,0 +1,8 @@
+type GetGlueJson = {
+    data: any;
+};
+/**
+ * @deprecated in favour of getJsonNewline
+ */
+declare const getGlueJson: ({ data }: GetGlueJson) => string;
+export default getGlueJson;

package/aws/s3/getGlueJson.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getJsonNewline_1 = __importDefault(require("../../json/getJsonNewline"));
+/**
+ * @deprecated in favour of getJsonNewline
+ */
+const getGlueJson = ({ data }) => (0, getJsonNewline_1.default)({ data });
+exports.default = getGlueJson;

package/aws/s3/getPresignedPost.d.ts

@@ -0,0 +1,20 @@
+type PresignedPost = {
+    url: string;
+    fields: any;
+};
+type GetPresignedPost = {
+    bucket: string;
+    conditions: any[];
+    expires: number;
+    fields: {
+        [key: string]: string;
+    };
+    key: string;
+};
+/**
+ * Returns a presigned post to upload a file directly to S3.
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_s3_presigned_post.html
+ * https://github.com/8millionstories-organisation/test-vercel-upload-2/blob/50eb12fcb3870a59ab455811bfaa1bdcb886edf2/pages/api/upload-url.js
+ */
+declare const getPresignedPost: ({ bucket, conditions, expires, fields, key }: GetPresignedPost) => Promise<PresignedPost>;
+export default getPresignedPost;

package/aws/s3/getPresignedPost.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Returns a presigned post to upload a file directly to S3.
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_s3_presigned_post.html
+ * https://github.com/8millionstories-organisation/test-vercel-upload-2/blob/50eb12fcb3870a59ab455811bfaa1bdcb886edf2/pages/api/upload-url.js
+ */
+const getPresignedPost = async ({ bucket, conditions, expires, fields, key }) => {
+    const { createPresignedPost } = require('@aws-sdk/client-s3');
+    const apiResponse = await createPresignedPost(global.awsS3Client, {
+        Bucket: bucket,
+        Key: key,
+        Conditions: undefined === conditions ? [] : conditions,
+        Fields: undefined === fields ? {} : fields,
+        Expires: undefined === expires ? 60 : expires, // Seconds
+    });
+    return apiResponse;
+};
+exports.default = getPresignedPost;

package/aws/s3/getSignedUrl.d.ts

@@ -0,0 +1,12 @@
+import { Response } from '../../api/response';
+type GetSignedUrl = {
+    bucket: string;
+    expires: number;
+    key: string;
+};
+/**
+ * Returns a signed for URL to allow download of private buckets for a given duration.
+ * Library: @aws-sdk/s3-request-presigner
+ */
+declare const getSignedUrl: ({ bucket, expires, key }: GetSignedUrl) => Promise<Response>;
+export default getSignedUrl;

package/aws/s3/getSignedUrl.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Returns a signed for URL to allow download of private buckets for a given duration.
+ * Library: @aws-sdk/s3-request-presigner
+ */
+const getSignedUrl = async ({ bucket, expires, key }) => {
+    const { GetObjectCommand } = require('@aws-sdk/client-s3');
+    const { getSignedUrl } = require('@aws-sdk/s3-request-presigner');
+    const command = new GetObjectCommand({
+        Bucket: bucket,
+        Key: key,
+    });
+    const response = await getSignedUrl(global.awsS3Client, command, { expiresIn: expires });
+    return response;
+};
+exports.default = getSignedUrl;

package/aws/s3/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-s3
+ */
+declare const initClient: ({ config }: InitClient) => void;
+export default initClient;

package/aws/s3/initClient.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getConfig_1 = __importDefault(require("../getConfig"));
+global.awsS3Client = null;
+/**
+ * Shorthand function to get the Lambda Client.
+ * Library: @aws-sdk/client-s3
+ */
+const initClient = ({ config }) => {
+    if (!global.awsS3Client) {
+        const { S3Client } = require('@aws-sdk/client-s3');
+        const formattedConfig = (0, getConfig_1.default)({ config });
+        global.awsS3Client = new S3Client(formattedConfig);
+    }
+};
+exports.default = initClient;

package/aws/s3/isFileExists.d.ts

@@ -0,0 +1,9 @@
+type IsFileExists = {
+    bucket: string;
+    key: string;
+};
+/**
+ * Check to see if a file exists but don't get the contents.
+ */
+declare const isFileExists: (props: IsFileExists) => Promise<boolean>;
+export default isFileExists;

package/aws/s3/isFileExists.js

@@ -0,0 +1,27 @@
+"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"));
+/**
+ * Check to see if a file exists but don't get the contents.
+ */
+const isFileExists = async (props) => {
+    let response = false;
+    try {
+        const { HeadObjectCommand } = require("@aws-sdk/client-s3");
+        // Fetch from S3
+        const apiResponse = await global.awsS3Client.send(new HeadObjectCommand({
+            Bucket: props.bucket,
+            Key: props.key,
+        }));
+        // If the status is 200 then it does exist
+        response = (0, isResponse200_1.default)({ apiResponse });
+    }
+    catch (exception) {
+        response = false;
+    }
+    return response;
+};
+exports.default = isFileExists;

package/aws/s3/listFiles.d.ts

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