@8ms/helpers 1.41.1 → 1.42.0

package/dist/esm/aws/ssm/getParameter.js

@@ -0,0 +1,38 @@
+global["awsSsmParameters"] = {};
+/**
+ * Get a parameter and decryption if necessary (secure string)
+ */
+const getParameter = async ({ name, withDecryption, isJson }) => {
+    // Haven't fetched already
+    if (undefined === global["awsSsmParameters"][name]) {
+        const { GetParameterCommand } = require('@aws-sdk/client-ssm');
+        const apiResponse = await global.awsSsmClient.send(new GetParameterCommand({
+            Name: name,
+            WithDecryption: undefined === withDecryption ? true : withDecryption,
+        }));
+        if (apiResponse.Parameter.Value) {
+            // Value is undefined
+            if (undefined === apiResponse.Parameter.Value) {
+                global["awsSsmParameters"][name] = null;
+            }
+            // Value is defined
+            else {
+                // isJson is default - decode
+                if (undefined === isJson || true === isJson) {
+                    global["awsSsmParameters"][name] = JSON.parse(apiResponse.Parameter.Value) || null;
+                }
+                // Not JSON don't decode
+                else {
+                    global["awsSsmParameters"][name] = apiResponse.Parameter.Value;
+                }
+            }
+        }
+        // Value not found (null so it can be sent from server to front end)
+        else {
+            global["awsSsmParameters"][name] = null;
+        }
+    }
+    // Return the loaded result
+    return global["awsSsmParameters"][name];
+};
+export default getParameter;

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

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

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

package/dist/esm/axios/delete.d.ts

@@ -0,0 +1,11 @@
+import ApiResponse from "../api/ApiResponse";
+export type Delete = {
+    config?: object;
+    url: string;
+};
+/**
+ * Make a DELETE request.
+ * Cant use the function name delete as its reserved
+ */
+declare const deleteRequest: (props: Delete) => Promise<ApiResponse>;
+export default deleteRequest;

package/dist/esm/axios/delete.js

@@ -0,0 +1,38 @@
+import ApiResponse from "../api/ApiResponse";
+/**
+ * Make a DELETE request.
+ * Cant use the function name delete as its reserved
+ */
+const deleteRequest = async (props) => {
+    const { default: ky } = await import("ky");
+    const response = await ky.delete(props.url, {
+        throwHttpErrors: false,
+        ...props.config
+    })
+        .then(async (response) => {
+        const data = await response.json();
+        // Is API response
+        if (undefined !== data.body && undefined !== data.error && undefined !== data.state) {
+            return new ApiResponse(data);
+        }
+        // General success - some APIs report 201
+        else if (response.status >= 200 && response.status <= 299) {
+            return (new ApiResponse()).setToSuccess({
+                body: data,
+            });
+        }
+        // Error
+        return (new ApiResponse()).setToError({
+            body: data,
+            error: response.statusText,
+        });
+    })
+        .catch(error => {
+        // Error
+        return (new ApiResponse()).setToError({
+            error: error.message,
+        });
+    });
+    return response;
+};
+export default deleteRequest;

package/dist/esm/axios/get.d.ts

@@ -0,0 +1,10 @@
+import ApiResponse from "../api/ApiResponse";
+export type Get = {
+    config?: object;
+    url: string;
+};
+/**
+ * Make a GET request.
+ */
+declare const get: ({ config, url }: Get) => Promise<ApiResponse>;
+export default get;

package/dist/esm/axios/get.js

@@ -0,0 +1,34 @@
+import ApiResponse from "../api/ApiResponse";
+/**
+ * Make a GET request.
+ */
+const get = async ({ config = {}, url }) => {
+    const { default: ky } = await import("ky");
+    const response = await ky.get(url, { throwHttpErrors: false, ...config })
+        .then(async (response) => {
+        const data = await response.json();
+        // Is API response
+        if (undefined !== data.body && undefined !== data.error && undefined !== data.state) {
+            return new ApiResponse(data);
+        }
+        // General success - some APIs report 201
+        else if (response.status >= 200 && response.status <= 299) {
+            return (new ApiResponse()).setToSuccess({
+                body: data,
+            });
+        }
+        // Error
+        return (new ApiResponse()).setToError({
+            body: data,
+            error: response.statusText,
+        });
+    })
+        .catch(error => {
+        // Error
+        return (new ApiResponse()).setToError({
+            error: error.message,
+        });
+    });
+    return response;
+};
+export default get;

package/dist/esm/axios/post.d.ts

@@ -0,0 +1,11 @@
+import ApiResponse from "../api/ApiResponse";
+export type Post = {
+    config?: object;
+    data?: object;
+    url: string;
+};
+/**
+ * Make a POST request.
+ */
+declare const post: ({ config, data, url }: Post) => Promise<ApiResponse>;
+export default post;

package/dist/esm/axios/post.js

@@ -0,0 +1,34 @@
+import ApiResponse from "../api/ApiResponse";
+/**
+ * Make a POST request.
+ */
+const post = async ({ config = {}, data = {}, url }) => {
+    const { default: ky } = await import("ky");
+    const response = await ky.post(url, { throwHttpErrors: false, json: data, ...config })
+        .then(async (response) => {
+        const data = await response.json();
+        // Is API response
+        if (undefined !== data.body && undefined !== data.error && undefined !== data.state) {
+            return new ApiResponse(data);
+        }
+        // General success - some APIs report 201
+        else if (response.status >= 200 && response.status <= 299) {
+            return (new ApiResponse()).setToSuccess({
+                body: data,
+            });
+        }
+        // Error
+        return (new ApiResponse()).setToError({
+            body: data,
+            error: response.statusText,
+        });
+    })
+        .catch(error => {
+        // Error
+        return (new ApiResponse()).setToError({
+            error: error.message,
+        });
+    });
+    return response;
+};
+export default post;

package/dist/esm/boolean/getBoolean.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Convert an input from a variety of forms into boolean.
+ */
+declare const getBoolean: ({ input }: {
+    input: any;
+}) => boolean;
+export default getBoolean;

package/dist/esm/boolean/getBoolean.js

@@ -0,0 +1,11 @@
+import isBoolean from 'lodash/isBoolean';
+/**
+ * Convert an input from a variety of forms into boolean.
+ */
+const getBoolean = ({ input }) => {
+    if (isBoolean(input)) {
+        return input;
+    }
+    return 'true' === input || 1 === input || '1' === input || 'yes' === input || 'y' === input;
+};
+export default getBoolean;

package/dist/esm/boolean/tests/getBoolean.test.d.ts

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

package/dist/esm/boolean/tests/getBoolean.test.js

@@ -0,0 +1,21 @@
+import getBoolean from '../getBoolean';
+test('getBoolean - True', () => {
+    expect(getBoolean({ input: true }))
+        .toBeTruthy();
+    expect(getBoolean({ input: 1 }))
+        .toBeTruthy();
+    expect(getBoolean({ input: '1' }))
+        .toBeTruthy();
+});
+test('getBoolean - False', () => {
+    expect(getBoolean({ input: false }))
+        .toBeFalsy();
+    expect(getBoolean({ input: 0 }))
+        .toBeFalsy();
+    expect(getBoolean({ input: '0' }))
+        .toBeFalsy();
+});
+test('getBoolean - Unexpected', () => {
+    expect(getBoolean({ input: 'test' }))
+        .toBeFalsy();
+});

package/dist/esm/brightData/getCustomerId.d.ts

@@ -0,0 +1,10 @@
+import { Param } from "./param";
+type GetCustomerId = {
+    auth: Param;
+    prefix?: string;
+};
+/**
+ * Return the customer Id based on the username.
+ */
+declare const getCustomerId: (props: GetCustomerId) => string;
+export default getCustomerId;

package/dist/esm/brightData/getCustomerId.js

@@ -0,0 +1,9 @@
+/**
+ * Return the customer Id based on the username.
+ */
+const getCustomerId = (props) => {
+    const segments = props.auth.username.split("-")[2];
+    const customerId = segments[2].replace("hl_", "");
+    return (props?.prefix || "") + customerId;
+};
+export default getCustomerId;

package/dist/esm/brightData/getZone.d.ts

@@ -0,0 +1,9 @@
+import { Param } from "./param";
+type GetZone = {
+    auth: Param;
+};
+/**
+ * Return the Zone based on the username.
+ */
+declare const getZone: (props: GetZone) => string;
+export default getZone;

package/dist/esm/brightData/getZone.js

@@ -0,0 +1,8 @@
+/**
+ * Return the Zone based on the username.
+ */
+const getZone = (props) => {
+    const segments = props.auth.username.split("-");
+    return segments[segments.length - 1];
+};
+export default getZone;

package/dist/esm/brightData/param.d.ts

@@ -0,0 +1,9 @@
+export type Param = {
+    apiKey: string;
+    host: string;
+    port: string;
+    username: string;
+    password: string;
+};
+declare const _default: {};
+export default _default;

package/dist/esm/brightData/param.js

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

package/dist/esm/brightData/serpApi/buildGoogleSerpUrl.d.ts

@@ -0,0 +1,32 @@
+type BuildGoogleSerpUrl = {
+    country?: string;
+    device?: "mobile" | "android" | "androidTablet" | "iphone" | "ipad";
+    language?: string;
+    geoLocation?: string;
+    hotel?: {
+        dates?: string;
+        occupancy?: number;
+    };
+    pagination?: {
+        offset?: number;
+        perPage?: number;
+    };
+    searchType?: "images" | "jobs" | "news" | "shopping" | "video";
+    query: string;
+    googleDomain: string;
+    output?: "html" | "json";
+    returnType: "url" | "json";
+};
+/**
+ * Construct the Google SERP url using Bright Data's API:
+ * https://brightdata.com/cp/serp_api/api/google/search?id=c_2cef083f
+ *
+ * For geolocation use value from:
+ * https://developers.google.com/google-ads/api/data/geotargets
+ */
+declare const buildGoogleSerpUrl: (props: BuildGoogleSerpUrl) => string | {
+    query: {
+        q: string;
+    };
+};
+export default buildGoogleSerpUrl;

package/dist/esm/brightData/serpApi/buildGoogleSerpUrl.js

@@ -0,0 +1,113 @@
+/**
+ * Construct the Google SERP url using Bright Data's API:
+ * https://brightdata.com/cp/serp_api/api/google/search?id=c_2cef083f
+ *
+ * For geolocation use value from:
+ * https://developers.google.com/google-ads/api/data/geotargets
+ */
+const buildGoogleSerpUrl = (props) => {
+    let url = new URL(`https://www.${props.googleDomain}/search`);
+    let params = {
+        query: {
+            q: props.query,
+        }
+    };
+    url.searchParams.append("q", props.query);
+    // Two-letter country code used to define the country of search
+    if (props?.country) {
+        params.query["gl"] = props.country;
+        url.searchParams.append("gl", props.country);
+    }
+    // Define what device type to be represented in user-agent - Default desktop
+    switch (props?.device) {
+        case "mobile":
+            params.query["brd_mobile"] = "1";
+            url.searchParams.append("brd_mobile", "1");
+            break;
+        case "android":
+            params.query["brd_mobile"] = "android";
+            url.searchParams.append("brd_mobile", "android");
+            break;
+        case "androidTablet":
+            params.query["brd_mobile"] = "android_tablet";
+            url.searchParams.append("brd_mobile", "android_tablet");
+            break;
+        case "ipad":
+            params.query["brd_mobile"] = "ipad";
+            url.searchParams.append("brd_mobile", "ipad");
+            break;
+        case "iphone":
+            params.query["brd_mobile"] = "ios";
+            url.searchParams.append("brd_mobile", "ios");
+            break;
+    }
+    // Stands for the encoded location you want to use for your search
+    if (props?.geoLocation) {
+        params.query["uule"] = props.geoLocation;
+        url.searchParams.append("uule", props.geoLocation);
+    }
+    if (props?.hotel) {
+        if (props.hotel?.dates) {
+            params.query["hotel_dates"] = props.hotel.dates.toString();
+            url.searchParams.append("hotel_dates", props.hotel.dates);
+        }
+        if (props.hotel?.occupancy) {
+            params.query["hotel_occupancy"] = props.hotel.occupancy.toString();
+            url.searchParams.append("hotel_occupancy", props.hotel.occupancy.toString());
+        }
+    }
+    // Two-letter language code used to define the page language
+    if (props?.language) {
+        params.query["uule"] = props.language;
+        url.searchParams.append("hl", props.language);
+    }
+    // Define search type. For regular search
+    switch (props?.searchType) {
+        case "images":
+            params.query["tbm"] = "isch";
+            url.searchParams.append("tbm", "isch");
+            break;
+        case "jobs":
+            params.query["ibp"] = "htl;jobs";
+            url.searchParams.append("ibp", "htl;jobs");
+            break;
+        case "news":
+            params.query["tbm"] = "nws";
+            url.searchParams.append("tbm", "nws");
+            break;
+        case "shopping":
+            params.query["tbm"] = "shop";
+            url.searchParams.append("tbm", "shop");
+            break;
+        case "video":
+            params.query["tbm"] = "vid";
+            url.searchParams.append("tbm", "vid");
+            break;
+    }
+    if (props?.pagination) {
+        // Define the result offset
+        if (props.pagination?.offset) {
+            params.query["start"] = props.pagination.offset.toString();
+            url.searchParams.append("start", props.pagination.offset.toString());
+        }
+        // Defines the number of results to return
+        if (props.pagination?.perPage) {
+            params.query["num"] = props.pagination.offset.toString();
+            url.searchParams.append("num", props.pagination.perPage.toString());
+        }
+    }
+    // Specify the output type
+    if ("json" === props.output) {
+        params["brd_json"] = "1";
+        url.searchParams.append("brn_json", "1");
+    }
+    else {
+        params["brd_json"] = "html";
+        url.searchParams.append("brn_json", "html");
+    }
+    if ("json" === props.returnType) {
+        return params;
+    }
+    return url.toString();
+};
+export default buildGoogleSerpUrl;

package/dist/esm/brightData/serpApi/buildGoogleTrendsUrl.d.ts

@@ -0,0 +1,22 @@
+type BuildGoogleTrendsUrl = {
+    country?: string;
+    language?: string;
+    category?: string;
+    date?: string;
+    searchType?: "images" | "news" | "shopping" | "youtube";
+    query: string;
+    returnType: "url" | "json";
+};
+/**
+ * Construct the Google Trends url using Bright Data's API:
+ * https://brightdata.com/cp/serp_api/api/google/trends?id=c_2cef083f
+ *
+ * For category use value from:
+ * https://trends.google.com/trends/api/explore/pickers/category?lang=en-US&tz=240
+ */
+declare const buildGoogleTrendsUrl: (props: BuildGoogleTrendsUrl) => string | {
+    query: {
+        q: string;
+    };
+};
+export default buildGoogleTrendsUrl;

package/dist/esm/brightData/serpApi/buildGoogleTrendsUrl.js

@@ -0,0 +1,58 @@
+/**
+ * Construct the Google Trends url using Bright Data's API:
+ * https://brightdata.com/cp/serp_api/api/google/trends?id=c_2cef083f
+ *
+ * For category use value from:
+ * https://trends.google.com/trends/api/explore/pickers/category?lang=en-US&tz=240
+ */
+const buildGoogleTrendsUrl = (props) => {
+    let url = new URL(`http://trends.google.com/trends/explore`);
+    url.searchParams.append("q", props.query);
+    let params = {
+        query: {
+            q: props.query,
+        }
+    };
+    // Location of interest, two-letter country code
+    if (props?.country) {
+        params.query['geo'] = props.country;
+        url.searchParams.append("geo", props.country);
+    }
+    // Preferred language, two-letter language code
+    if (props?.language) {
+        params.query['hl'] = props.language;
+        url.searchParams.append("hl", props.language);
+    }
+    if (props?.category) {
+        params.query['cat'] = props.category;
+        url.searchParams.append("cat", props.category);
+    }
+    if (props?.date) {
+        params.query['date'] = props.date;
+        url.searchParams.append("date", props.date);
+    }
+    // Define search type. For regular search
+    switch (props?.searchType) {
+        case "images":
+            params.query['group'] = "images";
+            url.searchParams.append("gprop", "images");
+            break;
+        case "news":
+            params.query['group'] = "news";
+            url.searchParams.append("gprop", "news");
+            break;
+        case "shopping":
+            params.query['group'] = "froogle";
+            url.searchParams.append("gprop", "froogle");
+            break;
+        case "youtube":
+            params.query['group'] = "youtube";
+            url.searchParams.append("gprop", "youtube");
+            break;
+    }
+    if ("json" === props.returnType) {
+        return params;
+    }
+    return url.toString();
+};
+export default buildGoogleTrendsUrl;

package/dist/esm/brightData/serpApi/getAsyncRequestId.d.ts

@@ -0,0 +1,14 @@
+import { Param } from "../param";
+import { Type } from "./type";
+type GetAsyncRequestId = {
+    auth: Param;
+    data: object;
+    type: Type;
+};
+/**
+ * Make an async request to the SERP API using the Bright Data proxy.
+ * Returns a request ID used with getAsyncResults
+ * https://docs.brightdata.com/scraping-automation/serp-api/asynchronous-requests
+ */
+declare const getAsyncRequestId: (props: GetAsyncRequestId) => Promise<string>;
+export default getAsyncRequestId;

package/dist/esm/brightData/serpApi/getAsyncRequestId.js

@@ -0,0 +1,45 @@
+import post from "../../axios/post";
+import getCustomerId from "../getCustomerId";
+import getZone from "../getZone";
+import { Type } from "./type";
+/**
+ * Make an async request to the SERP API using the Bright Data proxy.
+ * Returns a request ID used with getAsyncResults
+ * https://docs.brightdata.com/scraping-automation/serp-api/asynchronous-requests
+ */
+const getAsyncRequestId = async (props) => {
+    let url = "";
+    let response = "";
+    // Prevent auth requests getting blocked
+    process.env["NODE_TLS_REJECT_UNAUTHORIZED"] = "0";
+    const customerId = getCustomerId({
+        auth: props.auth,
+    });
+    const zone = getZone({
+        auth: props.auth,
+    });
+    switch (props.type) {
+        case Type.GOOGLE_TRENDS:
+            url = `https://api.brightdata.com/serp/trends?customer=${customerId}&zone=${zone}`;
+            break;
+        default:
+            url = `https://api.brightdata.com/serp/req?customer=${customerId}&zone=${zone}`;
+    }
+    const requestResponse = await post({
+        config: {
+            headers: {
+                Authorization: `Bearer ${props.auth.apiKey}`
+            },
+        },
+        data: props?.data || {},
+        url,
+    });
+    if (requestResponse.isSuccess()) {
+        response = requestResponse.getBodyDefaultTo({
+            defaultValue: "",
+            keys: ["response_id"],
+        });
+    }
+    return response;
+};
+export default getAsyncRequestId;

package/dist/esm/brightData/serpApi/getAsyncResults.d.ts

@@ -0,0 +1,12 @@
+import { Param } from "../param";
+import ApiResponse from "../../api/ApiResponse";
+type GetAsync = {
+    auth: Param;
+    requestId: string;
+};
+/**
+ * Using the request ID from getAsyncRequestId fetch to see if the data is available.
+ * https://docs.brightdata.com/scraping-automation/serp-api/asynchronous-requests
+ */
+declare const getAsyncResults: (props: GetAsync) => Promise<ApiResponse>;
+export default getAsyncResults;

package/dist/esm/brightData/serpApi/getAsyncResults.js

@@ -0,0 +1,44 @@
+import get from "../../axios/get";
+import getCustomerId from "../getCustomerId";
+import getZone from "../getZone";
+import ApiResponse from "../../api/ApiResponse";
+/**
+ * Using the request ID from getAsyncRequestId fetch to see if the data is available.
+ * https://docs.brightdata.com/scraping-automation/serp-api/asynchronous-requests
+ */
+const getAsyncResults = async (props) => {
+    let response = (new ApiResponse());
+    // Prevent auth requests getting blocked
+    process.env["NODE_TLS_REJECT_UNAUTHORIZED"] = "0";
+    const customerId = getCustomerId({
+        auth: props.auth,
+    });
+    const zone = getZone({
+        auth: props.auth,
+    });
+    const requestResponse = await get({
+        config: {
+            headers: {
+                Authorization: `Bearer ${props.auth.apiKey}`
+            },
+        },
+        url: `https://api.brightdata.com/serp/get_result?customer=${customerId}&zone=${zone}&response_id=${props.requestId}`,
+    });
+    if (requestResponse.isSuccess()) {
+        if ("Request is pending" === requestResponse.getBody()) {
+            response.setToPending();
+        }
+        else {
+            response.setToSuccess({
+                body: requestResponse.getBody(),
+            });
+        }
+    }
+    else {
+        response.setToError({
+            error: "Error in request",
+        });
+    }
+    return response;
+};
+export default getAsyncResults;