@8ms/helpers 2.0.0 → 2.0.2

package/swr/index.d.ts

@@ -0,0 +1,42 @@
+import { ApiState } from "../api";
+export type Swr = {
+    data: any;
+    onSuccess?: Function;
+    skipFetch?: boolean;
+    url: string;
+};
+export type SwrResponse = {
+    data: any;
+    error: any;
+    fetcher: Function;
+    mutate: {
+        data: any;
+        url: string;
+    };
+    state?: ApiState;
+    swrMutate: Function;
+};
+/**
+ * Check to see if a single SWR has an error.
+ */
+export declare const isData: (swr: SwrResponse) => boolean;
+/**
+ * Check to see if a single SWR is loading.
+ */
+export declare const isLoading: (swr: SwrResponse) => boolean;
+/**
+ * Check to see if a single SWR has an error.
+ */
+export declare const isError: (swr: SwrResponse) => boolean;
+/**
+ * Are any of SWRs loading
+ */
+export declare const isAnyLoading: (swrs: SwrResponse[]) => boolean;
+/**
+ * Are any of the SWRs marked as an error.
+ */
+export declare const isAnyError: (swrs: SwrResponse[]) => boolean;
+/**
+ * Are all SWRs data ready.
+ */
+export declare const isAllData: (swrs: SwrResponse[]) => boolean;

package/swr/index.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAllData = exports.isAnyError = exports.isAnyLoading = exports.isError = exports.isLoading = exports.isData = void 0;
+/**
+ * Check to see if a single SWR has an error.
+ */
+const isData = (swr) => (undefined === swr.error || null === swr.error) &&
+    "undefined" !== typeof swr.data &&
+    "undefined" !== swr.data;
+exports.isData = isData;
+/**
+ * Check to see if a single SWR is loading.
+ */
+const isLoading = (swr) => !(0, exports.isError)(swr) && !(0, exports.isData)(swr);
+exports.isLoading = isLoading;
+/**
+ * Check to see if a single SWR has an error.
+ */
+const isError = (swr) => undefined !== swr.error && null !== swr.error;
+exports.isError = isError;
+/**
+ * Are any of SWRs loading
+ */
+const isAnyLoading = (swrs) => {
+    let counter = 0;
+    for (const swr in swrs) {
+        if ((0, exports.isLoading)(swrs[swr])) {
+            counter++;
+        }
+    }
+    return counter > 0;
+};
+exports.isAnyLoading = isAnyLoading;
+/**
+ * Are any of the SWRs marked as an error.
+ */
+const isAnyError = (swrs) => {
+    let counter = 0;
+    for (const swr in swrs) {
+        if ((0, exports.isError)(swrs[swr])) {
+            counter++;
+        }
+    }
+    return counter > 0;
+};
+exports.isAnyError = isAnyError;
+/**
+ * Are all SWRs data ready.
+ */
+const isAllData = (swrs) => {
+    let counter = 0;
+    for (const swr in swrs) {
+        if ((0, exports.isData)(swrs[swr])) {
+            counter++;
+        }
+    }
+    return counter === Object.keys(swrs).length;
+};
+exports.isAllData = isAllData;

package/upTimeRobot/UpTimeRobotNamespace.d.ts

@@ -0,0 +1,31 @@
+import { UpTimeRobotConfig } from "./index";
+import { BaseNamespace } from "../_class";
+type GetReportProps = {
+    custom_uptime_ranges?: string;
+    logs?: boolean;
+    logs_start_date?: string;
+    logs_end_date?: string;
+    monitors?: string | string[];
+    response_times?: boolean;
+    response_times_start_date?: string;
+    response_times_end_date?: string;
+    search?: string;
+    statuses?: number | number[];
+    types?: number | number[];
+    limit?: number;
+    offset?: number;
+};
+/**
+ * Use the Up Time Robot API to retrieve up to 50 monitors at a time.
+ * https://uptimerobot.com/api/
+ */
+export declare class UpTimeRobotNamespace extends BaseNamespace {
+    client: boolean | null;
+    config: UpTimeRobotConfig | null;
+    /**
+     * Renew the access token as it expires every 3 hours.
+     */
+    ensureInit: () => Promise<void>;
+    getReport: (props?: GetReportProps) => Promise<any>;
+}
+export {};

package/upTimeRobot/UpTimeRobotNamespace.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 });
+exports.UpTimeRobotNamespace = void 0;
+const _class_1 = require("../_class");
+const axios_1 = require("../axios");
+const isArray_1 = __importDefault(require("lodash/isArray"));
+/**
+ * Use the Up Time Robot API to retrieve up to 50 monitors at a time.
+ * https://uptimerobot.com/api/
+ */
+class UpTimeRobotNamespace extends _class_1.BaseNamespace {
+    constructor() {
+        super(...arguments);
+        this.client = null;
+        this.config = null;
+        /**
+         * Renew the access token as it expires every 3 hours.
+         */
+        this.ensureInit = async () => {
+            if (!this.client) {
+                this.client = true;
+            }
+        };
+        this.getReport = async (props) => {
+            let response = null;
+            let finalParams = {};
+            if (undefined !== props) {
+                finalParams = {
+                    ...props,
+                };
+                if (undefined !== props.monitors && (0, isArray_1.default)(props.monitors)) {
+                    finalParams["monitors"] = props.monitors.join("-");
+                }
+                if (undefined !== props.statuses && (0, isArray_1.default)(props.statuses)) {
+                    finalParams["statuses"] = props.statuses.join("-");
+                }
+                if (undefined !== props.types && (0, isArray_1.default)(props.types)) {
+                    finalParams["types"] = props.types.join("-");
+                }
+            }
+            const apiResponse = await (0, axios_1.post)(`https://api.uptimerobot.com/v2/getMonitors?api_key=${this.config.apiKey}`, finalParams);
+            if (apiResponse.isSuccess()) {
+                response = apiResponse.getBody();
+            }
+            return response;
+        };
+    }
+}
+exports.UpTimeRobotNamespace = UpTimeRobotNamespace;

package/upTimeRobot/index.d.ts

@@ -0,0 +1,38 @@
+import { LittleWardenNamespace } from "../littleWarden/LittleWardenNamespace";
+export type UpTimeRobotConfig = {
+    apiKey: string;
+};
+export declare const upTimeRobotClient: (key?: string, config?: UpTimeRobotConfig, vaultId?: string, itemId?: string) => Promise<LittleWardenNamespace>;
+export declare const logTypes: {
+    DOWN: number;
+    UP: number;
+    PAUSED: number;
+    STARTED: number;
+};
+export declare const monitorStatuses: {
+    PAUSED: number;
+    NOT_CHECKED: number;
+    UP: number;
+    SEEMS_DOWN: number;
+    DOWN: number;
+};
+export declare const monitorSubTypes: {
+    HTTP: number;
+    HTTPS: number;
+    FTP: number;
+    SMTP: number;
+    POP3: number;
+    IMAP: number;
+    CUSTOM_PORT: number;
+};
+export declare const monitorTypes: {
+    HTTPS: number;
+    KEYWORD: number;
+    PING: number;
+    PORT: number;
+    HEARTBEAT: number;
+};
+export declare const requestStatuses: {
+    ERROR: string;
+    SUCCESS: string;
+};

package/upTimeRobot/index.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestStatuses = exports.monitorTypes = exports.monitorSubTypes = exports.monitorStatuses = exports.logTypes = exports.upTimeRobotClient = void 0;
+const LittleWardenNamespace_1 = require("../littleWarden/LittleWardenNamespace");
+const onePassword_1 = require("../onePassword");
+const upTimeRobotNamespaces = new Map();
+const upTimeRobotClient = async (key = "default", config, vaultId, itemId) => {
+    if (upTimeRobotNamespaces.has(key)) {
+        return upTimeRobotNamespaces.get(key);
+    }
+    let instanceConfig;
+    if (config) {
+        instanceConfig = config;
+    }
+    else if (vaultId && itemId) {
+        instanceConfig = await (await (0, onePassword_1.onePasswordClient)())
+            .getJsonNote(vaultId, itemId);
+    }
+    else if ("default" === key && process.env.UP_TIME_ROBOT_VAULT_ID && process.env.UP_TIME_ROBOT_ITEM_ID) {
+        instanceConfig = await (await (0, onePassword_1.onePasswordClient)())
+            .getJsonNote(process.env.UP_TIME_ROBOT_VAULT_ID, process.env.UP_TIME_ROBOT_ITEM_ID);
+    }
+    else {
+        throw new Error(`Config required for namespace '${key}'`);
+    }
+    const namespace = new LittleWardenNamespace_1.LittleWardenNamespace(key, instanceConfig);
+    upTimeRobotNamespaces.set(key, namespace);
+    return namespace;
+};
+exports.upTimeRobotClient = upTimeRobotClient;
+exports.logTypes = {
+    DOWN: 1,
+    UP: 2,
+    PAUSED: 99,
+    STARTED: 98,
+};
+exports.monitorStatuses = {
+    PAUSED: 0,
+    NOT_CHECKED: 1,
+    UP: 2,
+    SEEMS_DOWN: 8,
+    DOWN: 9,
+};
+exports.monitorSubTypes = {
+    HTTP: 1,
+    HTTPS: 2,
+    FTP: 3,
+    SMTP: 4,
+    POP3: 5,
+    IMAP: 6,
+    CUSTOM_PORT: 99,
+};
+exports.monitorTypes = {
+    HTTPS: 1,
+    KEYWORD: 2,
+    PING: 3,
+    PORT: 4,
+    HEARTBEAT: 5,
+};
+exports.requestStatuses = {
+    ERROR: 'fail',
+    SUCCESS: 'ok',
+};

package/url/index.d.ts

@@ -0,0 +1,30 @@
+export type EnvironmentUrl = {
+    localhost: string;
+    development: string;
+    staging: string;
+    production: string;
+};
+/**
+ * Does the URL begin with HTTP or HTTPS?
+ */
+export declare const isAbsolute: (input: string) => boolean;
+/**
+ * Does the URL begin with a slash.
+ */
+export declare const isRelative: (input: string) => boolean;
+/**
+ * Take an object and return the parameter for a given URL irrespective of path.
+ */
+export declare const buildParameters: (existing?: object, updated?: object) => string;
+/**
+ * Create a new relative URL based on the current path.
+ */
+export declare const buildRelative: ({ router, updated }: {
+    router: any;
+    updated: object;
+}) => string;
+/**
+ * Get the current base url.
+ */
+export declare const buildEnvironmentUrl: (path: string, url: EnvironmentUrl) => string;
+export { writeUrlContents } from "./writeUrlContents";

package/url/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeUrlContents = exports.buildEnvironmentUrl = exports.buildRelative = exports.buildParameters = exports.isRelative = exports.isAbsolute = void 0;
+const environment_1 = require("../environment");
+const merge_1 = __importDefault(require("lodash/merge"));
+/**
+ * Does the URL begin with HTTP or HTTPS?
+ */
+const isAbsolute = (input) => {
+    try {
+        new URL(input);
+    }
+    catch (error) {
+        return false;
+    }
+    return true;
+};
+exports.isAbsolute = isAbsolute;
+/**
+ * Does the URL begin with a slash.
+ */
+const isRelative = (input) => "/" === input.trim()
+    .charAt(0);
+exports.isRelative = isRelative;
+/**
+ * Take an object and return the parameter for a given URL irrespective of path.
+ */
+const buildParameters = (existing = {}, updated = {}) => {
+    const merged = (0, merge_1.default)(existing, updated);
+    let response = "";
+    if (Object.values(merged).length) {
+        for (const key in merged) {
+            const value = undefined === updated[key] ? existing[key] : updated[key];
+            response += "" === response ? "?" : "&";
+            response += `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+        }
+    }
+    return response;
+};
+exports.buildParameters = buildParameters;
+/**
+ * Create a new relative URL based on the current path.
+ */
+const buildRelative = ({ router, updated }) => {
+    return `${router.pathname}${(0, exports.buildParameters)({ existing: router.query, updated: updated || {} })}`;
+};
+exports.buildRelative = buildRelative;
+/**
+ * Get the current base url.
+ */
+const buildEnvironmentUrl = (path, url) => {
+    let response;
+    if ((0, environment_1.isDevelopment)() && (0, environment_1.isLocalhost)()) {
+        response = url.localhost;
+    }
+    else if ((0, environment_1.isStaging)()) {
+        response = url.staging;
+    }
+    else if ((0, environment_1.isProduction)()) {
+        response = url.production;
+    }
+    else {
+        response = url.development;
+    }
+    return response + path || "";
+};
+exports.buildEnvironmentUrl = buildEnvironmentUrl;
+var writeUrlContents_1 = require("./writeUrlContents");
+Object.defineProperty(exports, "writeUrlContents", { enumerable: true, get: function () { return writeUrlContents_1.writeUrlContents; } });

package/url/writeUrlContents.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Downloads a given URL's contents to a local file.
+ *
+ * Requires fs-extra
+ */
+export declare const writeUrlContents: (filePath: string, url: string) => Promise<void>;

package/url/writeUrlContents.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeUrlContents = void 0;
+const axios_1 = __importDefault(require("axios"));
+const file_1 = require("../file");
+/**
+ * Downloads a given URL's contents to a local file.
+ *
+ * Requires fs-extra
+ */
+const writeUrlContents = async (filePath, url) => {
+    const fs = await Promise.resolve().then(() => __importStar(require("fs-extra")));
+    await (0, file_1.createDirectory)(filePath);
+    const writer = fs.createWriteStream(filePath);
+    await (0, axios_1.default)({
+        method: "get",
+        url,
+        responseType: "stream"
+    })
+        .then(response => {
+        return new Promise(async (resolve, reject) => {
+            response.data.pipe(writer);
+            let error = null;
+            writer.on("error", err => {
+                error = err;
+                writer.close();
+                reject(err);
+            });
+            writer.on("close", () => {
+                if (!error) {
+                    resolve(true);
+                }
+                //no need to call the reject here, as it will have been called in the
+                //'error' stream;
+            });
+        });
+    });
+};
+exports.writeUrlContents = writeUrlContents;

package/util/defaultTo.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Function to default to a value, whilst filtering through an instance
+ */
+export declare const defaultTo: (instance: any, keys: any | any[], defaultValue?: any) => any;

package/util/defaultTo.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 });
+exports.defaultTo = void 0;
+const isObject_1 = __importDefault(require("lodash/isObject"));
+const array_1 = require("../array");
+/**
+ * Function to default to a value, whilst filtering through an instance
+ */
+const defaultTo = (instance, keys, defaultValue = null) => {
+    const keysArray = (0, array_1.getArray)(keys);
+    let found = true;
+    let pointer = instance;
+    // Instance is undefined or is null
+    if ("undefined" === typeof instance || null === pointer) {
+        found = false;
+    }
+    // Instance exists
+    else {
+        keysArray.forEach(key => {
+            if (found) {
+                // Sub key doesn't exist
+                if ((0, isObject_1.default)(pointer)) {
+                    // @ts-ignore
+                    if (undefined === pointer[key] || null === pointer[key]) {
+                        found = false;
+                    }
+                    // Sub key exists, update pointer
+                    else {
+                        // @ts-ignore
+                        pointer = pointer[key];
+                    }
+                }
+                else {
+                    found = false;
+                }
+            }
+        });
+    }
+    return found ? pointer : defaultValue;
+};
+exports.defaultTo = defaultTo;

package/util/getBrotliCompressed.d.ts

@@ -0,0 +1,5 @@
+import { type BrotliOptions } from "zlib";
+/**
+ * Compress a given input using Brotli.
+ */
+export declare const getBrotliCompressed: (input: any, options?: BrotliOptions) => Promise<unknown>;

package/util/getBrotliCompressed.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 });
+exports.getBrotliCompressed = void 0;
+const zlib_1 = __importDefault(require("zlib"));
+/**
+ * Compress a given input using Brotli.
+ */
+const getBrotliCompressed = async (input, options = {}) => {
+    return new Promise(async (resolve, reject) => {
+        zlib_1.default.brotliCompress(input || "", options || {}, (err, data) => {
+            if (err) {
+                reject(`Error compressing - ${err.message}`);
+            }
+            else {
+                resolve(data.toString("base64"));
+            }
+        });
+    });
+};
+exports.getBrotliCompressed = getBrotliCompressed;

package/util/getBrotliDecompressed.d.ts

@@ -0,0 +1,5 @@
+import { type BrotliOptions } from "zlib";
+/**
+ * Decompress a given Brotli input into a string.
+ */
+export declare const getBrotliDecompressed: (input: any, options?: BrotliOptions) => Promise<unknown>;

package/util/getBrotliDecompressed.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBrotliDecompressed = void 0;
+const zlib_1 = __importDefault(require("zlib"));
+/**
+ * Decompress a given Brotli input into a string.
+ */
+const getBrotliDecompressed = async (input, options = {}) => {
+    return new Promise(async (resolve, reject) => {
+        const compressedData = Buffer.from(input || '', "base64");
+        zlib_1.default.brotliDecompress(compressedData, options || {}, (err, data) => {
+            if (err) {
+                reject(`Error decompressing - ${err.message}`);
+            }
+            else {
+                resolve(data.toString('utf8'));
+            }
+        });
+    });
+};
+exports.getBrotliDecompressed = getBrotliDecompressed;

package/util/getClean.d.ts

@@ -0,0 +1,11 @@
+type GetClean = {
+    hash?: boolean;
+    input: any;
+    lowercase?: boolean;
+    parameter?: boolean;
+};
+/**
+ * Return a clean URL with a few options.
+ */
+export declare const getClean: (props: GetClean) => string;
+export {};

package/util/getClean.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClean = void 0;
+const getWithoutParameter_1 = require("./getWithoutParameter");
+const getWithoutHash_1 = require("./getWithoutHash");
+/**
+ * Return a clean URL with a few options.
+ */
+const getClean = (props) => {
+    let response = props.input.toString()
+        .trim();
+    if (props.parameter) {
+        response = (0, getWithoutParameter_1.getWithoutParameter)(response);
+    }
+    if (props.hash) {
+        response = (0, getWithoutHash_1.getWithoutHash)(response);
+    }
+    if (props.lowercase) {
+        response = response.toLowerCase();
+    }
+    return response;
+};
+exports.getClean = getClean;

package/util/getGzipCompressed.d.ts

@@ -0,0 +1,5 @@
+import { type ZlibOptions } from "zlib";
+/**
+ * Compress a given input using Gzip.
+ */
+export declare const getGzipCompressed: (input: any, options?: ZlibOptions) => Promise<unknown>;

package/util/getGzipCompressed.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 });
+exports.getGzipCompressed = void 0;
+const zlib_1 = __importDefault(require("zlib"));
+/**
+ * Compress a given input using Gzip.
+ */
+const getGzipCompressed = async (input, options = {}) => {
+    return new Promise(async (resolve, reject) => {
+        zlib_1.default.gzip(input || "", options || {}, (err, data) => {
+            if (err) {
+                reject(`Error compressing - ${err.message}`);
+            }
+            else {
+                resolve(data.toString("base64"));
+            }
+        });
+    });
+};
+exports.getGzipCompressed = getGzipCompressed;

package/util/getGzipDecompressed.d.ts

@@ -0,0 +1,5 @@
+import { type ZlibOptions } from "zlib";
+/**
+ * Decompress a given Gzip input into a string.
+ */
+export declare const getGzipDecompressed: (input: any, options?: ZlibOptions) => Promise<unknown>;