@8ms/helpers 2.0.0 → 2.0.2

package/.github/workflows/deploy_npmjs.yml

@@ -18,6 +18,13 @@ jobs:
 
             -   run: yarn set version berry
 
+            # Install ALL dependencies (including devDependencies with TypeScript)
+            -   run: yarn install --immutable
+
+            # Build the project (TypeScript now available)
+            -   run: yarn build
+
+            # Optional: prune to production-only after build
             -   run: yarn workspaces focus --production
 
             -   uses: JS-DevTools/npm-publish@v3.1.1

package/_class/BaseClass.d.ts

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

package/_class/BaseClass.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseClass = void 0;
+const isArray_1 = __importDefault(require("lodash/isArray"));
+const set_1 = __importDefault(require("lodash/set"));
+const util_1 = require("../util");
+class BaseClass {
+    constructor() {
+        /**
+         * Shortcut to set a value to an array and return the instance.
+         */
+        this._setArray = (fields, input) => {
+            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.
+         */
+        this._setValue = (fields, input) => {
+            (0, set_1.default)(this, fields, input);
+            return this;
+        };
+        /**
+         * Shortcut to add a value to an existing array.
+         */
+        this._push = (fields, input) => {
+            let temp = this._get(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.
+         */
+        this._get = (fields, defaultValue = null) => {
+            return (0, util_1.defaultTo)(this, fields, defaultValue);
+        };
+    }
+}
+exports.BaseClass = BaseClass;

package/_class/BaseNamespace.d.ts

@@ -0,0 +1,9 @@
+export declare class BaseNamespace {
+    client: any;
+    key: string;
+    config: any;
+    constructor(key: string, config: any);
+    ensureInit: () => Promise<void>;
+    reset: () => void;
+    getClient: () => Promise<any>;
+}

package/_class/BaseNamespace.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseNamespace = void 0;
+const environment_1 = require("../environment");
+class BaseNamespace {
+    constructor(key, config) {
+        this.client = null;
+        this.config = null;
+        // To be superseded by child
+        this.ensureInit = async () => {
+        };
+        // Reset the client
+        this.reset = () => {
+            this.client = null;
+        };
+        // Return the raw client if needed
+        this.getClient = async () => {
+            return this.client();
+        };
+        if (!environment_1.isServer) {
+            throw new Error("Server-side only class accessed from client");
+        }
+        this.key = key;
+        this.config = config;
+    }
+}
+exports.BaseNamespace = BaseNamespace;

package/_class/index.d.ts

@@ -0,0 +1,2 @@
+export { BaseClass } from "./BaseClass";
+export { BaseNamespace } from "./BaseNamespace";

package/_class/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseNamespace = exports.BaseClass = void 0;
+var BaseClass_1 = require("./BaseClass");
+Object.defineProperty(exports, "BaseClass", { enumerable: true, get: function () { return BaseClass_1.BaseClass; } });
+var BaseNamespace_1 = require("./BaseNamespace");
+Object.defineProperty(exports, "BaseNamespace", { enumerable: true, get: function () { return BaseNamespace_1.BaseNamespace; } });

package/adverity/getJobs.d.ts

@@ -0,0 +1,15 @@
+import { InputDate } from "../date";
+import { JobSchemaType } from "./index";
+type AdverityJobsResponse = {
+    count: number;
+    next: string | null;
+    previous: string | null;
+    results: JobSchemaType[];
+};
+/**
+ * Fetch all the jobs that ran yesterday by default.
+ * A job can either by in Fetch, Enrich or Transfer states, but all have different job ids. This makes it difficult to track and we would be reliant on the start/end time which could varu.
+ * As a result, we only store the Transfer jobs as this is when it gets moved into Bigquery. If it's not in Bigquery we cant use it anyway.
+ */
+export declare const getJobs: (apiKey: string, start?: InputDate, end?: InputDate, url?: string) => Promise<AdverityJobsResponse[]>;
+export {};

package/adverity/getJobs.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJobs = void 0;
+const date_1 = require("../date");
+const axios_1 = require("../axios");
+/**
+ * Fetch all the jobs that ran yesterday by default.
+ * A job can either by in Fetch, Enrich or Transfer states, but all have different job ids. This makes it difficult to track and we would be reliant on the start/end time which could varu.
+ * As a result, we only store the Transfer jobs as this is when it gets moved into Bigquery. If it's not in Bigquery we cant use it anyway.
+ */
+const getJobs = async (apiKey, start, end, url) => {
+    const startYmd = (0, date_1.getYmdString)(start ? (0, date_1.getDate)(start) : (0, date_1.getYesterday)());
+    const endYmd = (0, date_1.getYmdString)(end ? (0, date_1.getDate)(end) : (0, date_1.getToday)());
+    const finalUrl = "undefined" !== typeof url ? url : `https://8ms.datatap.adverity.com/api/jobs/?start=${startYmd}&end=${endYmd}&page_size=300`;
+    let response = [];
+    const apiResponse = await (0, axios_1.get)(finalUrl, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+        }
+    });
+    if (apiResponse.isSuccess()) {
+        const apiResponseBody = apiResponse.getBody();
+        // Move to the next page
+        if (apiResponseBody.next) {
+            response = [...apiResponse.getBody(), await (0, exports.getJobs)(apiKey, start, end, apiResponseBody.next)];
+        }
+    }
+    return response;
+};
+exports.getJobs = getJobs;

package/adverity/index.d.ts

@@ -0,0 +1,112 @@
+import { z } from "zod/v4";
+export declare const stackSchema: z.ZodObject<{
+    id: z.ZodString;
+    uuid: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    url: z.ZodString;
+    change_url: z.ZodString;
+    extracts_url: z.ZodString;
+    issues_url: z.ZodString;
+    overview_url: z.ZodString;
+    permissions: z.ZodObject<{
+        isCreator: z.ZodBoolean;
+        isDatastreamManager: z.ZodBoolean;
+        isViewer: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type StackSchemaType = z.infer<typeof stackSchema>;
+export declare const datastreamSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    stack: z.ZodObject<{
+        id: z.ZodString;
+        uuid: z.ZodString;
+        name: z.ZodString;
+        slug: z.ZodString;
+        url: z.ZodString;
+        change_url: z.ZodString;
+        extracts_url: z.ZodString;
+        issues_url: z.ZodString;
+        overview_url: z.ZodString;
+        permissions: z.ZodObject<{
+            isCreator: z.ZodBoolean;
+            isDatastreamManager: z.ZodBoolean;
+            isViewer: z.ZodBoolean;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    stack_id: z.ZodNumber;
+    name: z.ZodString;
+    slug: z.ZodString;
+    app_label: z.ZodString;
+    absolute_url: z.ZodString;
+    change_url: z.ZodString;
+    extracts_url: z.ZodString;
+    fetch_url: z.ZodString;
+    overview_url: z.ZodString;
+    schema_mapping_url: z.ZodString;
+    enabled: z.ZodBigInt;
+    next_run: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"Not Scheduled">]>;
+    url: z.ZodString;
+    datastream_type_id: z.ZodNumber;
+    logo_url: z.ZodString;
+    extracts_stream_url: z.ZodString;
+    supports_extended_intervals: z.ZodNumber;
+    updated: z.ZodString;
+    created: z.ZodString;
+    creator: z.ZodString;
+    can_be_fetched: z.ZodNumber;
+}, z.core.$strip>;
+export type DatastreamSchemaType = z.infer<typeof datastreamSchema>;
+export declare const jobSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    url: z.ZodString;
+    job_start: z.ZodNullable<z.ZodString>;
+    job_end: z.ZodNullable<z.ZodString>;
+    progress: z.ZodNumber;
+    state: z.ZodNumber;
+    state_label: z.ZodString;
+    state_color: z.ZodString;
+    datastream: z.ZodObject<{
+        id: z.ZodNumber;
+        stack: z.ZodObject<{
+            id: z.ZodString;
+            uuid: z.ZodString;
+            name: z.ZodString;
+            slug: z.ZodString;
+            url: z.ZodString;
+            change_url: z.ZodString;
+            extracts_url: z.ZodString;
+            issues_url: z.ZodString;
+            overview_url: z.ZodString;
+            permissions: z.ZodObject<{
+                isCreator: z.ZodBoolean;
+                isDatastreamManager: z.ZodBoolean;
+                isViewer: z.ZodBoolean;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        stack_id: z.ZodNumber;
+        name: z.ZodString;
+        slug: z.ZodString;
+        app_label: z.ZodString;
+        absolute_url: z.ZodString;
+        change_url: z.ZodString;
+        extracts_url: z.ZodString;
+        fetch_url: z.ZodString;
+        overview_url: z.ZodString;
+        schema_mapping_url: z.ZodString;
+        enabled: z.ZodBigInt;
+        next_run: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"Not Scheduled">]>;
+        url: z.ZodString;
+        datastream_type_id: z.ZodNumber;
+        logo_url: z.ZodString;
+        extracts_stream_url: z.ZodString;
+        supports_extended_intervals: z.ZodNumber;
+        updated: z.ZodString;
+        created: z.ZodString;
+        creator: z.ZodString;
+        can_be_fetched: z.ZodNumber;
+    }, z.core.$strip>;
+    issues: z.ZodArray<z.ZodAny>;
+    type: z.ZodUnion<readonly [z.ZodString, z.ZodString, z.ZodString]>;
+}, z.core.$strip>;
+export type JobSchemaType = z.infer<typeof jobSchema>;

package/adverity/index.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jobSchema = exports.datastreamSchema = exports.stackSchema = void 0;
+const v4_1 = require("zod/v4");
+exports.stackSchema = v4_1.z.object({
+    id: v4_1.z.string(),
+    uuid: v4_1.z.string(),
+    name: v4_1.z.string(),
+    slug: v4_1.z.string(),
+    url: v4_1.z.string(),
+    change_url: v4_1.z.string(),
+    extracts_url: v4_1.z.string(),
+    issues_url: v4_1.z.string(),
+    overview_url: v4_1.z.string(),
+    permissions: v4_1.z.object({
+        isCreator: v4_1.z.boolean(),
+        isDatastreamManager: v4_1.z.boolean(),
+        isViewer: v4_1.z.boolean(),
+    })
+});
+exports.datastreamSchema = v4_1.z.object({
+    id: v4_1.z.number(),
+    stack: exports.stackSchema,
+    stack_id: v4_1.z.number(),
+    name: v4_1.z.string(),
+    slug: v4_1.z.string(),
+    app_label: v4_1.z.string(),
+    absolute_url: v4_1.z.string(),
+    change_url: v4_1.z.string(),
+    extracts_url: v4_1.z.string(),
+    fetch_url: v4_1.z.string(),
+    overview_url: v4_1.z.string(),
+    schema_mapping_url: v4_1.z.string(),
+    enabled: v4_1.z.bigint(),
+    next_run: v4_1.z.union([v4_1.z.string(), v4_1.z.literal("Not Scheduled")]),
+    url: v4_1.z.string(),
+    datastream_type_id: v4_1.z.number(),
+    logo_url: v4_1.z.string(),
+    extracts_stream_url: v4_1.z.string(),
+    supports_extended_intervals: v4_1.z.number(),
+    updated: v4_1.z.string(),
+    created: v4_1.z.string(),
+    creator: v4_1.z.string(),
+    can_be_fetched: v4_1.z.number(),
+});
+exports.jobSchema = v4_1.z.object({
+    id: v4_1.z.number(),
+    url: v4_1.z.string(),
+    job_start: v4_1.z.string()
+        .nullable(),
+    job_end: v4_1.z.string()
+        .nullable(),
+    progress: v4_1.z.number(),
+    state: v4_1.z.number(),
+    state_label: v4_1.z.string(),
+    state_color: v4_1.z.string(),
+    datastream: exports.datastreamSchema,
+    issues: v4_1.z.any()
+        .array(),
+    type: v4_1.z.union([v4_1.z.string("Fetch"), v4_1.z.string("Enrich"), v4_1.z.string("Transfer")]),
+});

package/api/ApiResponseClass.d.ts

@@ -0,0 +1,35 @@
+import { ApiState, ApiResponse } from "./";
+import { z } from "zod/v4";
+type ConstructorProps = {
+    body?: any;
+    error?: any;
+    state?: ApiState;
+};
+/**
+ * Class version of the API to enable quicker instances.
+ */
+export declare class ApiResponseClass<T = any, E = any> {
+    state: ApiState;
+    body: T | null;
+    error: E | null;
+    constructor({ body, error, state }?: ConstructorProps);
+    fromJson: (input: ApiResponse) => this;
+    getBody: () => any;
+    getBodyDefaultTo: (keys: any | any[], defaultValue: any) => any;
+    getError: () => any;
+    getJson: () => ApiResponse<T, E>;
+    getApiState: () => ApiState;
+    isError: () => boolean;
+    isIdle: () => boolean;
+    isPending: () => boolean;
+    isSuccess: () => boolean;
+    setToIdle: () => this;
+    setToPending: () => this;
+    setToError: (body: any, error: any) => this;
+    setToSuccess: (body: any) => this;
+    setBody: (body: any) => this;
+    setError: (error: any) => this;
+    setApiState: (state: ApiState) => this;
+    validateZod: <T_1>(schema: z.ZodSchema<T_1>) => ApiResponseClass<T_1, E>;
+}
+export {};

package/api/ApiResponseClass.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiResponseClass = void 0;
+const util_1 = require("../util");
+const _1 = require("./");
+/**
+ * Class version of the API to enable quicker instances.
+ */
+class ApiResponseClass {
+    constructor({ body, error, state } = {}) {
+        this.state = _1.ApiState.IDLE;
+        this.body = null;
+        this.error = null;
+        this.fromJson = (input) => {
+            this.body = input.body;
+            this.error = input.error;
+            this.state = input.state;
+            return this;
+        };
+        this.getBody = () => {
+            return this.body;
+        };
+        this.getBodyDefaultTo = (keys, defaultValue) => {
+            return (0, util_1.defaultTo)(this.body, keys, defaultValue);
+        };
+        this.getError = () => {
+            return this.error;
+        };
+        this.getJson = () => {
+            return {
+                body: this.body,
+                error: this.error,
+                state: this.state,
+            };
+        };
+        this.getApiState = () => {
+            return this.state;
+        };
+        this.isError = () => {
+            return this.state === _1.ApiState.ERROR;
+        };
+        this.isIdle = () => {
+            return this.state === _1.ApiState.IDLE;
+        };
+        this.isPending = () => {
+            return this.state === _1.ApiState.PENDING;
+        };
+        this.isSuccess = () => {
+            return this.state === _1.ApiState.SUCCESS;
+        };
+        this.setToIdle = () => {
+            this.state = _1.ApiState.IDLE;
+            return this;
+        };
+        this.setToPending = () => {
+            this.state = _1.ApiState.PENDING;
+            return this;
+        };
+        this.setToError = (body, error) => {
+            this.body = body || null;
+            this.error = error;
+            this.state = _1.ApiState.ERROR;
+            return this;
+        };
+        this.setToSuccess = (body) => {
+            this.body = body;
+            this.state = _1.ApiState.SUCCESS;
+            return this;
+        };
+        this.setBody = (body) => {
+            this.body = body;
+            return this;
+        };
+        this.setError = (error) => {
+            this.error = error;
+            return this;
+        };
+        this.setApiState = (state) => {
+            this.state = state;
+            return this;
+        };
+        this.validateZod = (schema) => {
+            try {
+                const validatedBody = schema.parse(this.body);
+                return new ApiResponseClass({ body: validatedBody, state: this.state });
+            }
+            catch (error) {
+                return new ApiResponseClass({ error, state: _1.ApiState.ERROR });
+            }
+        };
+        this.body = body || null;
+        this.error = error || null;
+        this.state = state || _1.ApiState.IDLE;
+        return this;
+    }
+}
+exports.ApiResponseClass = ApiResponseClass;

package/api/index.d.ts

@@ -0,0 +1,22 @@
+export { ApiResponseClass } from "./ApiResponseClass";
+export declare enum ApiState {
+    CANCELLED = "CANCELLED",
+    ERROR = "ERROR",
+    IDLE = "IDLE",
+    PENDING = "PENDING",
+    SUCCESS = "SUCCESS",
+    VALIDATION_ERROR = "VALIDATION_ERROR"
+}
+export type ApiResponse<T = any, E = any> = {
+    body: T | null;
+    error: E | null;
+    state: ApiState;
+};
+export declare const defaultResponse: ApiResponse;
+export declare const unexpectedError: string;
+export declare const isCancelled: (apiResponse: ApiResponse) => boolean;
+export declare const isError: (apiResponse: ApiResponse) => boolean;
+export declare const isIdle: (apiResponse: ApiResponse) => boolean;
+export declare const isPending: (apiResponse: ApiResponse) => boolean;
+export declare const isSuccess: (apiResponse: ApiResponse) => boolean;
+export declare const isValidationError: (apiResponse: ApiResponse) => boolean;

package/api/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidationError = exports.isSuccess = exports.isPending = exports.isIdle = exports.isError = exports.isCancelled = exports.unexpectedError = exports.defaultResponse = exports.ApiState = exports.ApiResponseClass = void 0;
+var ApiResponseClass_1 = require("./ApiResponseClass");
+Object.defineProperty(exports, "ApiResponseClass", { enumerable: true, get: function () { return ApiResponseClass_1.ApiResponseClass; } });
+var ApiState;
+(function (ApiState) {
+    ApiState["CANCELLED"] = "CANCELLED";
+    ApiState["ERROR"] = "ERROR";
+    ApiState["IDLE"] = "IDLE";
+    ApiState["PENDING"] = "PENDING";
+    ApiState["SUCCESS"] = "SUCCESS";
+    ApiState["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+})(ApiState || (exports.ApiState = ApiState = {}));
+exports.defaultResponse = {
+    body: null,
+    error: null,
+    state: ApiState.IDLE,
+};
+exports.unexpectedError = "An unexpected error occurred, please try again.";
+const isCancelled = (apiResponse) => {
+    return ApiState.CANCELLED === apiResponse.state;
+};
+exports.isCancelled = isCancelled;
+const isError = (apiResponse) => {
+    return ApiState.ERROR === apiResponse.state;
+};
+exports.isError = isError;
+const isIdle = (apiResponse) => {
+    return ApiState.IDLE === apiResponse.state;
+};
+exports.isIdle = isIdle;
+const isPending = (apiResponse) => {
+    return ApiState.PENDING === apiResponse.state;
+};
+exports.isPending = isPending;
+const isSuccess = (apiResponse) => {
+    return ApiState.SUCCESS === apiResponse.state;
+};
+exports.isSuccess = isSuccess;
+const isValidationError = (apiResponse) => {
+    return ApiState.VALIDATION_ERROR === apiResponse.state;
+};
+exports.isValidationError = isValidationError;

package/array/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shorthand to check if an array or string contains a needle.
+ */
+export declare const contains: <T>(haystack: T[], needle: T) => boolean;
+/**
+ * Convert an array into an array or return if already an array.
+ */
+export declare const getArray: <T>(input: T) => T[];

package/array/index.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 });
+exports.getArray = exports.contains = void 0;
+const isArray_1 = __importDefault(require("lodash/isArray"));
+/**
+ * Shorthand to check if an array or string contains a needle.
+ */
+const contains = (haystack, needle) => -1 !== haystack.indexOf(needle);
+exports.contains = contains;
+/**
+ * Convert an array into an array or return if already an array.
+ */
+const getArray = (input) => (0, isArray_1.default)(input) ? input : [input];
+exports.getArray = getArray;

package/atInternet/index.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod/v4";
+/**
+ * The request in the structure required by AT Internet.
+ */
+export declare const requestSchema: z.ZodObject<{
+    columns: z.ZodArray<z.ZodString>;
+    evo: z.ZodObject<{}, z.core.$strip>;
+    filter: z.ZodObject<{}, z.core.$strip>;
+    "max-results": z.ZodNumber;
+    options: z.ZodObject<{
+        ignore_null_properties: z.ZodBoolean;
+    }, z.core.$strip>;
+    "page-num": z.ZodNumber;
+    period: z.ZodObject<{}, z.core.$strip>;
+}, z.core.$strip>;
+export type RequestSchemaType = z.infer<typeof requestSchema>;

package/atInternet/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestSchema = void 0;
+const v4_1 = require("zod/v4");
+/**
+ * The request in the structure required by AT Internet.
+ */
+exports.requestSchema = v4_1.z.object({
+    columns: v4_1.z.array(v4_1.z.string()),
+    evo: v4_1.z.object({}),
+    filter: v4_1.z.object({}),
+    "max-results": v4_1.z.number(),
+    options: v4_1.z.object({
+        "ignore_null_properties": v4_1.z.boolean(),
+    }),
+    "page-num": v4_1.z.number(),
+    period: v4_1.z.object({}),
+});

package/aws/athenaExpress/AwsAthenaNamespace.d.ts

@@ -0,0 +1,8 @@
+import { BaseNamespace } from "../../_class";
+import { AthenaConfig } from "./index";
+export declare class AwsAthenaNamespace extends BaseNamespace {
+    client: any | null;
+    config: AthenaConfig;
+    ensureInit: () => Promise<void>;
+    query: (query: string) => Promise<any>;
+}