@8ms/helpers 1.41.1 → 1.42.0

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

@@ -0,0 +1,10 @@
+import { Param } from "../param";
+type GetRealtime = {
+    auth: Param;
+    url: string;
+};
+/**
+ * Make a request to the SERP API using the Bright Data proxy
+ */
+declare const getRealtime: (props: GetRealtime) => Promise<{}>;
+export default getRealtime;

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

@@ -0,0 +1,30 @@
+import get from "../../axios/get";
+/**
+ * Make a request to the SERP API using the Bright Data proxy
+ */
+const getRealtime = async (props) => {
+    let response = {};
+    // Prevent auth requests getting blocked
+    process.env["NODE_TLS_REJECT_UNAUTHORIZED"] = "0";
+    // Use fetch with the agent option to make an HTTP request through the proxy
+    // Replace <target_url> with the URL you want to request
+    const apiResponse = await get({
+        config: {
+            proxy: {
+                protocol: "http",
+                host: props.auth.host,
+                port: props.auth.port,
+                auth: {
+                    username: props.auth.username,
+                    password: props.auth.password,
+                }
+            },
+        },
+        url: props.url,
+    });
+    if (apiResponse.isSuccess()) {
+        response = apiResponse.getBody();
+    }
+    return response;
+};
+export default getRealtime;

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

@@ -0,0 +1,11 @@
+export declare enum Type {
+    GOOGLE_FLIGHTS = "GOOGLE_FLIGHTS",
+    GOOGLE_HOTELS = "GOOGLE_HOTELS",
+    GOOGLE_LENS = "GOOGLE_LENS",
+    GOOGLE_MAPS = "GOOGLE_MAPS",
+    GOOGLE_REVIEWS = "GOOGLE_REVIEWS",
+    GOOGLE_SEARCH = "GOOGLE_SEARCH",
+    GOOGLE_TRENDS = "GOOGLE_TRENDS"
+}
+declare const _default: {};
+export default _default;

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

@@ -0,0 +1,11 @@
+export var Type;
+(function (Type) {
+    Type["GOOGLE_FLIGHTS"] = "GOOGLE_FLIGHTS";
+    Type["GOOGLE_HOTELS"] = "GOOGLE_HOTELS";
+    Type["GOOGLE_LENS"] = "GOOGLE_LENS";
+    Type["GOOGLE_MAPS"] = "GOOGLE_MAPS";
+    Type["GOOGLE_REVIEWS"] = "GOOGLE_REVIEWS";
+    Type["GOOGLE_SEARCH"] = "GOOGLE_SEARCH";
+    Type["GOOGLE_TRENDS"] = "GOOGLE_TRENDS";
+})(Type || (Type = {}));
+export default {};

package/dist/esm/brightData/webScraperIde/getBatch.d.ts

@@ -0,0 +1,14 @@
+import { Param } from "../param";
+type GetBatch = {
+    auth: Param;
+    data?: object;
+    scraperId: string;
+    isDev?: boolean;
+};
+/**
+ * Depends on the Scraper setup!
+ *
+ * Make the request to trigger the scraper and let it do its job.
+ */
+declare const getBatch: (props: GetBatch) => Promise<boolean>;
+export default getBatch;

package/dist/esm/brightData/webScraperIde/getBatch.js

@@ -0,0 +1,29 @@
+import post from "../../axios/post";
+/**
+ * Depends on the Scraper setup!
+ *
+ * Make the request to trigger the scraper and let it do its job.
+ */
+const getBatch = async (props) => {
+    let response = false;
+    const requestUrl = new URL('https://api.brightdata.com/dca/trigger');
+    requestUrl.searchParams.append('collector', props.scraperId);
+    requestUrl.searchParams.append('queue_next', '1');
+    if (props.isDev) {
+        requestUrl.searchParams.append('version', 'dev');
+    }
+    const requestResponse = await post({
+        config: {
+            headers: {
+                Authorization: `Bearer ${props.auth.apiKey}`
+            },
+        },
+        data: props?.data || {},
+        url: requestUrl.toString(),
+    });
+    if (requestResponse.isSuccess()) {
+        response = true;
+    }
+    return response;
+};
+export default getBatch;

package/dist/esm/brightData/webScraperIde/getRealtime.d.ts

@@ -0,0 +1,13 @@
+import { Param } from "../param";
+type GetRealtime = {
+    auth: Param;
+    data?: object;
+    scraperId: string;
+};
+/**
+ * Depends on the Scraper setup!
+ *
+ * Make the request and pool the response until the data is available.
+ */
+declare const getRealtime: (props: GetRealtime) => Promise<{}>;
+export default getRealtime;

package/dist/esm/brightData/webScraperIde/getRealtime.js

@@ -0,0 +1,59 @@
+import post from "../../axios/post";
+import { State } from "../../api";
+import get from "../../axios/get";
+import sleep from "../../util/sleep";
+/**
+ * Depends on the Scraper setup!
+ *
+ * Make the request and pool the response until the data is available.
+ */
+const getRealtime = async (props) => {
+    let response = {};
+    const requestUrl = `https://api.brightdata.com/dca/trigger_immediate?collector=${props.scraperId}`;
+    const requestResponse = await post({
+        config: {
+            headers: {
+                Authorization: `Bearer ${props.auth.apiKey}`
+            },
+        },
+        data: props?.data || {},
+        url: requestUrl,
+    });
+    if (requestResponse.isSuccess()) {
+        const responseId = requestResponse.getBodyDefaultTo({
+            defaultValue: "",
+            keys: ["response_id"],
+        });
+        if ("" !== responseId) {
+            let state = State.PENDING;
+            while (State.PENDING === state) {
+                const resultUrl = `https://api.brightdata.com/dca/get_result?response_id=${responseId}`;
+                // Use fetch with the agent option to make an HTTP request through the proxy
+                // Replace <target_url> with the URL you want to request
+                const resultResponse = await get({
+                    config: {
+                        headers: {
+                            Authorization: `Bearer ${props.auth.apiKey}`
+                        },
+                    },
+                    url: resultUrl,
+                });
+                if (resultResponse.isSuccess()) {
+                    if (undefined !== resultResponse.body.pending &&
+                        true === resultResponse.body.pending) {
+                        state = State.PENDING;
+                    }
+                    else {
+                        state = State.SUCCESS;
+                        response = resultResponse.getBody();
+                    }
+                }
+                await sleep({
+                    seconds: 1
+                });
+            }
+        }
+    }
+    return response;
+};
+export default getRealtime;

package/dist/esm/class/BaseClass.d.ts

@@ -0,0 +1,31 @@
+declare class BaseClass {
+    /**
+     * Shortcut to set a value to an array and return the instance.
+     */
+    protected _setArray({ input, fields }: {
+        input: any | any[];
+        fields: any | any[];
+    }): this;
+    /**
+     * Shortcut to set a value and return the instance.
+     */
+    protected _setValue({ input, fields }: {
+        input: any;
+        fields: any | any[];
+    }): this;
+    /**
+     * Shortcut to add a value to an existing array.
+     */
+    protected _push({ input, fields }: {
+        input: any | any[];
+        fields: any | any[];
+    }): this;
+    /**
+     * Shortcut to get a value, but default if the fields don't exist.
+     */
+    protected _get({ defaultValue, fields }: {
+        defaultValue: any;
+        fields: any | any[];
+    }): any;
+}
+export default BaseClass;

package/dist/esm/class/BaseClass.js

@@ -0,0 +1,45 @@
+import isArray from 'lodash/isArray';
+import set from 'lodash/set';
+import defaultTo from '../util/defaultTo';
+class BaseClass {
+    /**
+     * Shortcut to set a value to an array and return the instance.
+     */
+    _setArray({ input, fields }) {
+        if (isArray(input)) {
+            set(this, fields, input);
+        }
+        else {
+            set(this, fields, [input]);
+        }
+        return this;
+    }
+    /**
+     * Shortcut to set a value and return the instance.
+     */
+    _setValue({ input, fields }) {
+        set(this, fields, input);
+        return this;
+    }
+    /**
+     * Shortcut to add a value to an existing array.
+     */
+    _push({ input, fields }) {
+        let temp = this._get({ defaultValue: [], fields });
+        if (isArray(input)) {
+            temp = temp.concat(input);
+        }
+        else {
+            temp = temp.push(input);
+        }
+        set(this, fields, temp);
+        return this;
+    }
+    /**
+     * Shortcut to get a value, but default if the fields don't exist.
+     */
+    _get({ defaultValue, fields }) {
+        return defaultTo({ defaultValue, instance: this, keys: fields });
+    }
+}
+export default BaseClass;

package/dist/esm/crud/index.d.ts

@@ -0,0 +1,6 @@
+export declare enum Action {
+    CREATE = "CREATE",
+    READ = "READ",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE"
+}

package/dist/esm/crud/index.js

@@ -0,0 +1,7 @@
+export var Action;
+(function (Action) {
+    Action["CREATE"] = "CREATE";
+    Action["READ"] = "READ";
+    Action["UPDATE"] = "UPDATE";
+    Action["DELETE"] = "DELETE";
+})(Action || (Action = {}));

package/dist/esm/crypto/getDecrypt.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Decrypt an encoding string using a salt
+ * Library: crypto-js
+ */
+declare const getDecrypt: ({ appSalt, input, salt }: {
+    appSalt: string;
+    input: string;
+    salt: string;
+}) => string;
+export default getDecrypt;

package/dist/esm/crypto/getDecrypt.js

@@ -0,0 +1,11 @@
+/**
+ * Decrypt an encoding string using a salt
+ * Library: crypto-js
+ */
+const getDecrypt = ({ appSalt, input, salt }) => {
+    const { AES, enc } = require('crypto-js');
+    const customSalt = `${appSalt}-${salt}`;
+    return AES.decrypt(input, customSalt)
+        .toString(enc.Utf8);
+};
+export default getDecrypt;

package/dist/esm/crypto/getEncrypt.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Encrypt an encoding string using a salt
+ * Library: crypto-js
+ */
+declare const getEncrypt: ({ appSalt, input, salt }: {
+    appSalt: string;
+    input: string;
+    salt: string;
+}) => string;
+export default getEncrypt;

package/dist/esm/crypto/getEncrypt.js

@@ -0,0 +1,11 @@
+/**
+ * Encrypt an encoding string using a salt
+ * Library: crypto-js
+ */
+const getEncrypt = ({ appSalt, input, salt }) => {
+    const { AES } = require('crypto-js');
+    const customSalt = `${appSalt}-${salt}`;
+    return AES.encrypt(input, customSalt)
+        .toString();
+};
+export default getEncrypt;

package/dist/esm/crypto/getRandom.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Create a random string and return a number of characters from it.
+ * Library: crypto-js
+ */
+declare const getRandom: ({ length }: {
+    length: number;
+}) => string;
+export default getRandom;

package/dist/esm/crypto/getRandom.js

@@ -0,0 +1,10 @@
+/**
+ * Create a random string and return a number of characters from it.
+ * Library: crypto-js
+ */
+const getRandom = ({ length }) => {
+    return Math.random()
+        .toString(36)
+        .substr(0, length);
+};
+export default getRandom;

package/dist/esm/crypto/getSha256.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Encrypt a string using sha256
+ * Library: crypto-js
+ */
+declare const getSha256: ({ input }: {
+    input: any;
+}) => string;
+export default getSha256;

package/dist/esm/crypto/getSha256.js

@@ -0,0 +1,12 @@
+import getString from '../string/getString';
+/**
+ * Encrypt a string using sha256
+ * Library: crypto-js
+ */
+const getSha256 = ({ input }) => {
+    const { SHA256 } = require('crypto-js');
+    const inputString = getString({ input });
+    return SHA256(inputString)
+        .toString();
+};
+export default getSha256;

package/dist/esm/crypto/tests/getEncryptDecrypt.test.d.ts

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

package/dist/esm/crypto/tests/getEncryptDecrypt.test.js

@@ -0,0 +1,18 @@
+import getDecrypt from '../getDecrypt';
+import getEncrypt from '../getEncrypt';
+test('getEncrypt and getDecrypt', () => {
+    const input = 'this is a test';
+    // Value changes based on the time, cannot verify
+    const encrypted = getEncrypt({
+        appSalt: 'abc',
+        input,
+        salt: '123',
+    });
+    const decrypted = getDecrypt({
+        appSalt: 'abc',
+        input: encrypted,
+        salt: '123',
+    });
+    expect(input)
+        .toBe(decrypted);
+});

package/dist/esm/crypto/tests/getSha256.test.d.ts

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

package/dist/esm/crypto/tests/getSha256.test.js

@@ -0,0 +1,10 @@
+import getSha256 from '../getSha256';
+test('getSha256', () => {
+    const input = 'this is a test';
+    const expected = '2e99758548972a8e8822ad47fa1017ff72f06f3ff6a016851f45c398732bc50c';
+    const encrypted = getSha256({
+        input,
+    });
+    expect(encrypted)
+        .toBe(expected);
+});

package/dist/esm/date/format.d.ts

@@ -0,0 +1,10 @@
+import { GetDate } from "./getDate";
+type Format = GetDate & {
+    dateFormat?: string;
+};
+/**
+ * Convert a (number | string | Date) into a "yyyy-MM-dd" string or a specified format.
+ * As the user would be providing the input we don't want to change the timezone typically.
+ */
+declare const format: (props: Format) => string;
+export default format;

package/dist/esm/date/format.js

@@ -0,0 +1,16 @@
+import { format as dateFnsFormat } from "date-fns";
+import getDate from "./getDate";
+/**
+ * Convert a (number | string | Date) into a "yyyy-MM-dd" string or a specified format.
+ * As the user would be providing the input we don't want to change the timezone typically.
+ */
+const format = (props) => {
+    const dateInstance = getDate({
+        input: props.input,
+        isUtc: props.isUtc,
+        setMidnight: props?.setMidnight,
+        setTimeZone: props?.setTimeZone,
+    });
+    return dateFnsFormat(dateInstance, props?.dateFormat || "yyyy-MM-dd");
+};
+export default format;

package/dist/esm/date/getDate.d.ts

@@ -0,0 +1,14 @@
+import { DateType } from "./";
+import { GetMidnight } from "./getMidnight";
+import { GetTimeZoned } from "./getTimeZoned";
+export type GetDate = GetTimeZoned & GetMidnight & {
+    input: DateType;
+    isUtc?: boolean;
+};
+/**
+ * Convert a (number | string | Date) into a Date object.
+ * As the user would be providing the input we don't want to change the timezone typically.
+ * By default assumption is that the input is UTC, however it can be switched to timezoned time.
+ */
+declare const getDate: (props: GetDate) => Date;
+export default getDate;

package/dist/esm/date/getDate.js

@@ -0,0 +1,133 @@
+import getMidnight from "./getMidnight";
+/**
+ * Convert a (number | string | Date) into a Date object.
+ * As the user would be providing the input we don't want to change the timezone typically.
+ * By default assumption is that the input is UTC, however it can be switched to timezoned time.
+ */
+const getDate = (props) => {
+    let date;
+    let isUtc = undefined === props?.isUtc ? true : props.isUtc;
+    // Already date instance - no change
+    if (props.input instanceof Date) {
+        date = new Date(props.input.valueOf());
+    }
+    else if ("string" === typeof props.input || "number" === typeof props.input) {
+        // Convert the input into string
+        const dateString = props.input.toString();
+        const regexes = {
+            ymdDash: new RegExp("^[0-9]{4}-[0-9]{2}-[0-9]{2}$"),
+            ymdNumber: new RegExp("^[0-9]{8}$"),
+            ymdHisDash: new RegExp("^[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}$"),
+            ymdHisNumber: new RegExp("^[0-9]{14}$"),
+        };
+        //	console.log('regexes.ymdHisDash.test(dateString) ',regexes.ymdHisDash.test(dateString));
+        // 20220412
+        if (regexes.ymdNumber.test(dateString)) {
+            const year = Number(dateString.substring(0, 4));
+            const month = Number(dateString.substring(4, 6)) - 1;
+            const day = Number(dateString.substring(6, 8));
+            date = new Date();
+            // Reset the date to the 1st initially at 1am
+            date.setUTCDate(1);
+            date.setUTCHours(1, 0, 0, 0);
+            if (isUtc) {
+                date.setUTCFullYear(year);
+                date.setUTCMonth(month);
+                date.setUTCDate(day);
+                date.setUTCHours(0, 0, 0, 0);
+            }
+            else {
+                date.setFullYear(year);
+                date.setMonth(month);
+                date.setDate(day);
+                date.setHours(0, 0, 0, 0);
+            }
+        }
+        // 2022-04-12
+        else if (regexes.ymdDash.test(dateString)) {
+            const year = Number(dateString.substring(0, 4));
+            const month = Number(dateString.substring(5, 7)) - 1;
+            const day = Number(dateString.substring(8, 10));
+            date = new Date();
+            // Reset the date to the 1st initially at 1am
+            date.setUTCDate(1);
+            date.setUTCHours(1, 0, 0, 0);
+            // Finalise date
+            if (isUtc) {
+                date.setUTCFullYear(year);
+                date.setUTCMonth(month);
+                date.setUTCDate(day);
+                date.setUTCHours(0, 0, 0, 0);
+            }
+            else {
+                date.setFullYear(year);
+                date.setMonth(month);
+                date.setDate(day);
+                date.setHours(0, 0, 0, 0);
+            }
+        }
+        // 2022-04-12 01:01:01
+        else if (regexes.ymdHisDash.test(dateString)) {
+            const year = Number(dateString.substring(0, 4));
+            const month = Number(dateString.substring(5, 7)) - 1;
+            const day = Number(dateString.substring(8, 10));
+            const hours = Number(dateString.substring(11, 13));
+            const minutes = Number(dateString.substring(14, 16));
+            const seconds = Number(dateString.substring(17, 19));
+            date = new Date();
+            // Reset the date to the 1st initially at 1am
+            date.setUTCDate(1);
+            date.setUTCHours(1, 0, 0, 0);
+            // Finalise date
+            if (isUtc) {
+                date.setUTCFullYear(year);
+                date.setUTCMonth(month);
+                date.setUTCDate(day);
+                date.setUTCHours(hours, minutes, seconds);
+            }
+            else {
+                date.setFullYear(year);
+                date.setMonth(month);
+                date.setDate(day);
+                date.setHours(hours, minutes, seconds);
+            }
+        }
+        // 20220412010101
+        else if (regexes.ymdHisNumber.test(dateString)) {
+            const year = Number(dateString.substring(0, 4));
+            const month = Number(dateString.substring(4, 6)) - 1;
+            const day = Number(dateString.substring(6, 8));
+            const hours = Number(dateString.substring(8, 10));
+            const minutes = Number(dateString.substring(10, 12));
+            const seconds = Number(dateString.substring(12, 14));
+            date = new Date();
+            // Reset the date to the 1st initially at 1am
+            date.setUTCDate(1);
+            date.setUTCHours(1, 0, 0, 0);
+            // Finalise date
+            if (isUtc) {
+                date.setUTCFullYear(year);
+                date.setUTCMonth(month);
+                date.setUTCDate(day);
+                date.setUTCHours(hours, minutes, seconds);
+            }
+            else {
+                date.setFullYear(year);
+                date.setMonth(month);
+                date.setDate(day);
+                date.setHours(hours, minutes, seconds);
+            }
+        }
+        // Unsure date format, try anything
+        else {
+            date = new Date(dateString);
+        }
+    }
+    // Reset to midnight
+    date = getMidnight({
+        input: date,
+        setMidnight: props?.setMidnight,
+    });
+    return date;
+};
+export default getDate;

package/dist/esm/date/getDatesBetween.d.ts

@@ -0,0 +1,13 @@
+import { DateType } from "./";
+type GetDatesBetween = {
+    end: DateType;
+    start: DateType;
+    isUtc?: boolean;
+};
+/**
+ * Similar to date-fns' eachDayOfInterval, however the timezone messes this function up.
+ * https://date-fns.org/v2.28.0/docs/eachDayOfInterval
+ * https://www.gov.uk/when-do-the-clocks-change
+ */
+declare const getDatesBetween: (props: GetDatesBetween) => Date[];
+export default getDatesBetween;

package/dist/esm/date/getDatesBetween.js

@@ -0,0 +1,49 @@
+import { addDays } from "date-fns";
+import format from "./format";
+import getDate from "./getDate";
+import { addHours } from "date-fns";
+/**
+ * Similar to date-fns' eachDayOfInterval, however the timezone messes this function up.
+ * https://date-fns.org/v2.28.0/docs/eachDayOfInterval
+ * https://www.gov.uk/when-do-the-clocks-change
+ */
+const getDatesBetween = (props) => {
+    let response = [];
+    let endDate = getDate({
+        input: props.end,
+        isUtc: props.isUtc,
+    });
+    // Increase the end date by 2 hours so it can handle the change in hours
+    endDate = addHours(endDate, 2);
+    // Use a string to ensure there's no changes with the timezone
+    let startString = format({
+        input: props.start,
+        isUtc: props.isUtc,
+    });
+    // Create a pointer Date instance
+    let pointer = getDate({
+        input: startString,
+        isUtc: props.isUtc,
+    });
+    // While we before the end
+    while (pointer <= endDate) {
+        // We need to create a new date entry so its always set to 00:00:00
+        const entry = getDate({
+            input: pointer,
+            isUtc: props.isUtc,
+            setMidnight: true,
+        });
+        // Add this new entry to our response
+        response.push(entry);
+        // Move to the next day
+        pointer = addDays(pointer, 1);
+        // Daylight saving (month is 0-base)
+        // -1 hour between March and September, add an hour if 0 hours
+        // +1 hour between October and February
+        if (pointer.getMonth() >= 2 && pointer.getMonth() < 8 && 0 === pointer.getHours()) {
+            pointer = addHours(pointer, 1);
+        }
+    }
+    return response;
+};
+export default getDatesBetween;

package/dist/esm/date/getDurationHours.d.ts

@@ -0,0 +1,9 @@
+type GetDurationHours = {
+    seconds: number;
+};
+/**
+ * Convert a number of seconds into HH:MM:SS
+ * https://www.codevertiser.com/convert-seconds-to-hours-and-minutes-javascript/
+ */
+declare const getDurationHours: (props: GetDurationHours) => string;
+export default getDurationHours;