@8ms/helpers 1.40.6 → 1.40.10

package/brightData/webScraperIde/getRealtime.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const post_1 = __importDefault(require("../../axios/post"));
+const api_1 = require("../../api");
+const get_1 = __importDefault(require("../../axios/get"));
+const sleep_1 = __importDefault(require("../../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 (0, post_1.default)({
+        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 = api_1.State.PENDING;
+            while (api_1.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 (0, get_1.default)({
+                    config: {
+                        headers: {
+                            Authorization: `Bearer ${props.auth.apiKey}`
+                        },
+                    },
+                    url: resultUrl,
+                });
+                if (resultResponse.isSuccess()) {
+                    if (undefined !== resultResponse.body.pending &&
+                        true === resultResponse.body.pending) {
+                        state = api_1.State.PENDING;
+                    }
+                    else {
+                        state = api_1.State.SUCCESS;
+                        response = resultResponse.getBody();
+                    }
+                }
+                await (0, sleep_1.default)({
+                    seconds: 1
+                });
+            }
+        }
+    }
+    return response;
+};
+exports.default = getRealtime;

package/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/class/BaseClass.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isArray_1 = __importDefault(require("lodash/isArray"));
+const set_1 = __importDefault(require("lodash/set"));
+const defaultTo_1 = __importDefault(require("../util/defaultTo"));
+class BaseClass {
+    /**
+     * Shortcut to set a value to an array and return the instance.
+     */
+    _setArray({ input, fields }) {
+        if ((0, isArray_1.default)(input)) {
+            (0, set_1.default)(this, fields, input);
+        }
+        else {
+            (0, set_1.default)(this, fields, [input]);
+        }
+        return this;
+    }
+    /**
+     * Shortcut to set a value and return the instance.
+     */
+    _setValue({ input, fields }) {
+        (0, set_1.default)(this, fields, input);
+        return this;
+    }
+    /**
+     * Shortcut to add a value to an existing array.
+     */
+    _push({ input, fields }) {
+        let temp = this._get({ defaultValue: [], fields });
+        if ((0, isArray_1.default)(input)) {
+            temp = temp.concat(input);
+        }
+        else {
+            temp = temp.push(input);
+        }
+        (0, set_1.default)(this, fields, temp);
+        return this;
+    }
+    /**
+     * Shortcut to get a value, but default if the fields don't exist.
+     */
+    _get({ defaultValue, fields }) {
+        return (0, defaultTo_1.default)({ defaultValue, instance: this, keys: fields });
+    }
+}
+exports.default = BaseClass;

package/crud/index.d.ts

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

package/crud/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Action = void 0;
+var Action;
+(function (Action) {
+    Action["CREATE"] = "CREATE";
+    Action["READ"] = "READ";
+    Action["UPDATE"] = "UPDATE";
+    Action["DELETE"] = "DELETE";
+})(Action || (exports.Action = Action = {}));

package/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/crypto/getDecrypt.js

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

package/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/crypto/getEncrypt.js

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

package/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/crypto/getRandom.js

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

package/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/crypto/getSha256.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getString_1 = __importDefault(require("../string/getString"));
+/**
+ * Encrypt a string using sha256
+ * Library: crypto-js
+ */
+const getSha256 = ({ input }) => {
+    const { SHA256 } = require('crypto-js');
+    const inputString = (0, getString_1.default)({ input });
+    return SHA256(inputString)
+        .toString();
+};
+exports.default = getSha256;

package/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/date/format.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 date_fns_1 = require("date-fns");
+const getDate_1 = __importDefault(require("./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 = (0, getDate_1.default)({
+        input: props.input,
+        isUtc: props.isUtc,
+        setMidnight: props?.setMidnight,
+        setTimeZone: props?.setTimeZone,
+    });
+    return (0, date_fns_1.format)(dateInstance, props?.dateFormat || "yyyy-MM-dd");
+};
+exports.default = format;

package/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/date/getDate.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getMidnight_1 = __importDefault(require("./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 = (0, getMidnight_1.default)({
+        input: date,
+        setMidnight: props?.setMidnight,
+    });
+    return date;
+};
+exports.default = getDate;

package/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/date/getDatesBetween.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const date_fns_1 = require("date-fns");
+const format_1 = __importDefault(require("./format"));
+const getDate_1 = __importDefault(require("./getDate"));
+const date_fns_2 = require("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 = (0, getDate_1.default)({
+        input: props.end,
+        isUtc: props.isUtc,
+    });
+    // Increase the end date by 2 hours so it can handle the change in hours
+    endDate = (0, date_fns_2.addHours)(endDate, 2);
+    // Use a string to ensure there's no changes with the timezone
+    let startString = (0, format_1.default)({
+        input: props.start,
+        isUtc: props.isUtc,
+    });
+    // Create a pointer Date instance
+    let pointer = (0, getDate_1.default)({
+        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 = (0, getDate_1.default)({
+            input: pointer,
+            isUtc: props.isUtc,
+            setMidnight: true,
+        });
+        // Add this new entry to our response
+        response.push(entry);
+        // Move to the next day
+        pointer = (0, date_fns_1.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 = (0, date_fns_2.addHours)(pointer, 1);
+        }
+    }
+    return response;
+};
+exports.default = getDatesBetween;

package/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;

package/date/getDurationHours.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Convert a number of seconds into HH:MM:SS
+ * https://www.codevertiser.com/convert-seconds-to-hours-and-minutes-javascript/
+ */
+const getDurationHours = (props) => {
+    let response = '00:00:00';
+    if (props.seconds > 0) {
+        const calculated = {
+            hours: Math.floor(props.seconds / 3600),
+            minutes: Math.floor((props.seconds % 3600) / 60),
+            seconds: props.seconds % 60,
+        };
+        const output = {
+            hours: calculated.hours < 10 ? '0' + calculated.hours : calculated.hours,
+            minutes: calculated.minutes < 10 ? '0' + calculated.minutes : calculated.minutes,
+            seconds: calculated.seconds < 10 ? '0' + calculated.seconds : calculated.seconds,
+        };
+        response = `${output.hours}:${output.minutes}:${output.seconds}`;
+    }
+    return response;
+};
+exports.default = getDurationHours;

package/date/getDurationMinutes.d.ts

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

package/date/getDurationMinutes.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Convert a number of seconds into MM:SS
+ * https://www.codevertiser.com/convert-seconds-to-hours-and-minutes-javascript/
+ */
+const getDurationMinutes = (props) => {
+    let response = '00:00';
+    if (props.seconds > 0) {
+        const calculated = {
+            minutes: Math.floor((props.seconds % 3600) / 60),
+            seconds: props.seconds % 60,
+        };
+        const output = {
+            minutes: calculated.minutes < 10 ? '0' + calculated.minutes : calculated.minutes,
+            seconds: calculated.seconds < 10 ? '0' + calculated.seconds : calculated.seconds,
+        };
+        response = `${output.minutes}:${output.seconds}`;
+    }
+    return response;
+};
+exports.default = getDurationMinutes;

package/date/getFinancialYear.d.ts

@@ -0,0 +1,9 @@
+import { FinancialYear } from "./";
+type GetFinancialYearType = {
+    year?: number;
+};
+/**
+ * Get the current financial year.
+ */
+declare const getFinancialYear: (props?: GetFinancialYearType) => FinancialYear;
+export default getFinancialYear;

package/date/getFinancialYear.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const date_fns_1 = require("date-fns");
+const getDate_1 = __importDefault(require("./getDate"));
+const getToday_1 = __importDefault(require("./getToday"));
+/**
+ * Get the current financial year.
+ */
+const getFinancialYear = (props = {}) => {
+    // Either use the current year or a specified year
+    let financialYear = props.year;
+    if (undefined === props.year) {
+        // As this isn't provided by the suer, we want to ensure its London timezone
+        const today = (0, getToday_1.default)();
+        // If today is before 1st of April, then use last year
+        if (today < new Date(today.getFullYear(), 3, 1)) {
+            financialYear = today.getFullYear() - 1;
+        }
+        // On or after 1st of April, use this year
+        else {
+            financialYear = today.getFullYear();
+        }
+    }
+    // The year-end needs to be 31st March next year
+    // We are specifying the date, so don't change the timezone
+    let yearEnd = (0, getDate_1.default)({
+        input: `${financialYear + 1}-03-31`,
+        isUtc: true,
+    });
+    // The year start needs to be 1st April this year
+    // We are specifying the date, so don't change the timezone
+    let yearStart = (0, getDate_1.default)({
+        input: `${financialYear}-04-01`,
+        isUtc: true,
+    });
+    // Get the previous Monday if the 1st of April isn't a Monday
+    if (!(0, date_fns_1.isMonday)(yearStart)) {
+        yearStart = (0, date_fns_1.previousMonday)(yearStart);
+    }
+    // Get the next Sunday if the 31st of March isn't a Sunday
+    if (!(0, date_fns_1.isSunday)(yearEnd)) {
+        yearEnd = (0, date_fns_1.nextSunday)(yearEnd);
+    }
+    return {
+        end: yearEnd,
+        start: yearStart,
+    };
+};
+exports.default = getFinancialYear;

package/date/getFinancialYearToDate.d.ts

@@ -0,0 +1,7 @@
+import { FinancialYear } from './';
+/**
+ * Return the current financial year up to today.
+ * Timezone should always be London based
+ */
+declare const getFinancialYearToDate: () => FinancialYear;
+export default getFinancialYearToDate;