@8ms/helpers 1.40.6 → 1.40.10

package/google/bigQuery/initClient.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getConfig_1 = __importDefault(require("../getConfig"));
+global.googleBigQueryDefault = {
+    credentials: null,
+    projectId: null,
+};
+global.googleBigQueryClient = null;
+/**
+ * Initialise the Big Query client.
+ * It's possible to use multiple clients, so we set one up per project id.
+ */
+const initClient = ({ parameter, projectId }) => {
+    if (!global.googleBigQueryClient) {
+        const { BigQuery } = require('@google-cloud/bigquery');
+        const formattedConfig = (0, getConfig_1.default)({ parameter });
+        global.googleBigQueryDefault.credentials = formattedConfig;
+        global.googleBigQueryDefault.projectId = projectId;
+        global.googleBigQueryClient = new BigQuery({
+            credentials: global.googleBigQueryDefault.credentials,
+            location: "europe-west2",
+            projectId: global.googleBigQueryDefault.projectId,
+        });
+    }
+};
+exports.default = initClient;

package/google/bigQuery/isDatasetExists.d.ts

@@ -0,0 +1,11 @@
+type IsDatasetExists = {
+    datasetId: string;
+    projectId?: string;
+};
+/**
+ * Check to see whether a given BigQuery dataset exists.
+ * Based off:
+ * https://github.com/googleapis/nodejs-bigquery/blob/main/samples/getDataset.js
+ */
+declare const isDatasetExists: ({ datasetId, projectId }: IsDatasetExists) => Promise<boolean>;
+export default isDatasetExists;

package/google/bigQuery/isDatasetExists.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getClient_1 = __importDefault(require("./getClient"));
+/**
+ * Check to see whether a given BigQuery dataset exists.
+ * Based off:
+ * https://github.com/googleapis/nodejs-bigquery/blob/main/samples/getDataset.js
+ */
+const isDatasetExists = async ({ datasetId, projectId }) => {
+    let response;
+    let client = (0, getClient_1.default)({ projectId });
+    try {
+        await client.dataset(datasetId)
+            .get();
+        response = true;
+    }
+    catch (exception) {
+        response = false;
+    }
+    return response;
+};
+exports.default = isDatasetExists;

package/google/bigQuery/loadData.d.ts

@@ -0,0 +1,18 @@
+type LoadData = {
+    file: {
+        bucket: string;
+        key: string;
+        metadata: object;
+        projectId?: string;
+    };
+    table: {
+        projectId?: string;
+        datasetId: string;
+        tableId: string;
+    };
+};
+/**
+ * Load data into a given table.
+ */
+declare const loadData: ({ file, table }: LoadData) => Promise<void>;
+export default loadData;

package/google/bigQuery/loadData.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const IsTableExists_1 = __importDefault(require("./IsTableExists"));
+const getClient_1 = __importDefault(require("./getClient"));
+const getClient_2 = __importDefault(require("../storage/getClient"));
+/**
+ * Load data into a given table.
+ */
+const loadData = async ({ file, table }) => {
+    const tableExists = await (0, IsTableExists_1.default)({
+        datasetId: table.datasetId,
+        projectId: table.projectId,
+        tableId: table.tableId,
+    });
+    if (tableExists) {
+        let bigqueryClient = (0, getClient_1.default)({
+            projectId: table.projectId
+        });
+        let storageClient = (0, getClient_2.default)({
+            projectId: file.projectId
+        });
+        await bigqueryClient
+            .dataset(table.datasetId)
+            .table(table.tableId)
+            .load(storageClient.bucket(file.bucket)
+            .file(file.key), file.metadata);
+    }
+};
+exports.default = loadData;

package/google/bigQuery/query.d.ts

@@ -0,0 +1,19 @@
+/**
+ * https://cloud.google.com/bigquery/docs/parameterized-queries
+ */
+export type QueryInput = string | {
+    query: string;
+    location?: string;
+    params: {
+        [key: string]: any;
+    };
+};
+export type Query = {
+    input: QueryInput;
+    projectId?: string;
+};
+/**
+ * Build the query and return the data.
+ */
+declare const query: ({ input, projectId }: Query) => Promise<any>;
+export default query;

package/google/bigQuery/query.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getClient_1 = __importDefault(require("./getClient"));
+/**
+ * Build the query and return the data.
+ */
+const query = async ({ input, projectId }) => {
+    let client = (0, getClient_1.default)({ projectId });
+    const apiResponse = await client.query(input);
+    return apiResponse;
+};
+exports.default = query;

package/google/getConfig.d.ts

@@ -0,0 +1,20 @@
+export type Config = {
+    type: string;
+    project_id: string;
+    private_key_id: string;
+    private_key: string;
+    client_email: string;
+    client_id: string;
+    auth_uri: string;
+    token_uri: string;
+    auth_provider_x509_cert_url: string;
+    client_x509_cert_url: string;
+};
+export type GetConfig = {
+    parameter: Config;
+};
+/**
+ * Using the response from Parameter Store and format it ready to be used with Google API.
+ */
+declare const getConfig: ({ parameter }: GetConfig) => Config;
+export default getConfig;

package/google/getConfig.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Using the response from Parameter Store and format it ready to be used with Google API.
+ */
+const getConfig = ({ parameter }) => {
+    // Format the private key to be in the same format as required by Google
+    const privateKey = parameter['private_key'].replace(/\\n/g, '\n');
+    const response = {
+        type: parameter['type'],
+        project_id: parameter['project_id'],
+        private_key_id: parameter['private_key_id'],
+        private_key: privateKey,
+        client_email: parameter['client_email'],
+        client_id: parameter['client_id'],
+        auth_uri: parameter['auth_uri'],
+        token_uri: parameter['token_uri'],
+        auth_provider_x509_cert_url: parameter['auth_provider_x509_cert_url'],
+        client_x509_cert_url: parameter['client_x509_cert_url'],
+    };
+    return response;
+};
+exports.default = getConfig;

package/google/sheets/getAssociatedData.d.ts

@@ -0,0 +1,16 @@
+type GetAssociatedData = {
+    spreadsheetId: string;
+    ranges: [
+        format: string,
+        defaultRange: string,
+        heading: string,
+        data: string
+    ];
+    dateTimeRender: 'FORMATTED_STRING' | 'SERIAL_NUMBER';
+    valueRender: 'FORMATTED_VALUE' | 'UNFORMATTED_VALUE' | 'FORMULA';
+};
+/**
+ * Make a batch get to Google Sheets to retrieve the data correctly formatted, with default values provided.
+ */
+declare const getAssociatedData: ({ dateTimeRender, ranges, spreadsheetId, valueRender }: GetAssociatedData) => Promise<object[]>;
+export default getAssociatedData;

package/google/sheets/getAssociatedData.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 });
+const getBatchData_1 = __importDefault(require("./getBatchData"));
+/**
+ * Make a batch get to Google Sheets to retrieve the data correctly formatted, with default values provided.
+ */
+const getAssociatedData = async ({ dateTimeRender, ranges, spreadsheetId, valueRender }) => {
+    // Make the API request
+    const apiResponse = await (0, getBatchData_1.default)({
+        spreadsheetId,
+        ranges,
+        dateTimeRender,
+        valueRender,
+    });
+    let template = [];
+    let response = [];
+    // Missing ranges or too many ranges
+    if (4 !== apiResponse.valueRanges.length) {
+        throw new Error("Associated data response length must be 4.");
+    }
+    // Get the first data range
+    const initialRangeLength = apiResponse.valueRanges[0].values[0].length;
+    // Loop through the headings
+    for (let i = 0; i < initialRangeLength; i++) {
+        template.push({
+            format: apiResponse.valueRanges[0].values[0][i],
+            default: apiResponse.valueRanges[1].values[0][i],
+            heading: apiResponse.valueRanges[2].values[0][i],
+            index: i,
+        });
+    }
+    // console.log('template', template);
+    // Loop through each row of data
+    if (undefined !== apiResponse.valueRanges[3].values) {
+        for (let rowIndex = 0; rowIndex < apiResponse.valueRanges[3].values.length; rowIndex++) {
+            let row = {};
+            // Loop through each column within the row
+            for (let columnIndex = 0; columnIndex < apiResponse.valueRanges[3].values[rowIndex].length; columnIndex++) {
+                const refValue = apiResponse.valueRanges[3].values[rowIndex][columnIndex];
+                const value = ('' === refValue ? template[columnIndex]['default'] : refValue);
+                // Add this to our row
+                row[template[columnIndex]['heading']] = value;
+            }
+            // Add the row to our response
+            response.push(row);
+        }
+    }
+    return response;
+};
+exports.default = getAssociatedData;

package/google/sheets/getBatchData.d.ts

@@ -0,0 +1,18 @@
+type BatchData = {
+    spreadsheetId: string;
+    valueRanges: {
+        range: string;
+        majorDimension: 'rows' | 'dimension';
+        values: [
+            any[]
+        ];
+    }[];
+};
+type GetBatchData = {
+    spreadsheetId: string;
+    ranges: string[];
+    dateTimeRender?: string;
+    valueRender?: string;
+};
+declare const getBatchData: ({ spreadsheetId, ranges, dateTimeRender, valueRender, }: GetBatchData) => Promise<BatchData>;
+export default getBatchData;

package/google/sheets/getBatchData.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getBatchData = async ({ spreadsheetId, ranges, dateTimeRender = 'FORMATTED_STRING', valueRender = 'UNFORMATTED_VALUE', }) => {
+    const googleApisSheets = require('@googleapis/sheets');
+    const request = {
+        auth: global.googleSheetsClient,
+        dateTimeRenderOption: dateTimeRender,
+        ranges: ranges,
+        spreadsheetId: spreadsheetId,
+        valueRenderOption: valueRender,
+    };
+    // Make the API request
+    const apiResponse = (await googleApisSheets.sheets('v4')
+        .spreadsheets
+        .values
+        .batchGet(request));
+    return apiResponse.data;
+};
+exports.default = getBatchData;

package/google/sheets/initClient.d.ts

@@ -0,0 +1,11 @@
+import { Config } from '../getConfig';
+type InitClient = {
+    parameter: Config;
+};
+/**
+ * Initialise the Google Sheets instance using the separate service method.
+ * https://github.com/googleapis/google-api-nodejs-client
+ * Library: @googleapis/sheets
+ */
+declare const initClient: ({ parameter }: InitClient) => void;
+export default initClient;

package/google/sheets/initClient.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getConfig_1 = __importDefault(require("../getConfig"));
+global.googleSheetsClient = null;
+/**
+ * Initialise the Google Sheets instance using the separate service method.
+ * https://github.com/googleapis/google-api-nodejs-client
+ * Library: @googleapis/sheets
+ */
+const initClient = ({ parameter }) => {
+    if (!global.googleSheetsClient) {
+        const googleApisSheets = require('@googleapis/sheets');
+        const formattedConfig = (0, getConfig_1.default)({ parameter });
+        global.googleSheetsClient = new googleApisSheets.auth.GoogleAuth({
+            credentials: formattedConfig,
+            scopes: [
+                'https://www.googleapis.com/auth/spreadsheets',
+            ],
+        });
+    }
+};
+exports.default = initClient;

package/google/sheets/isCellNa.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Noticed sometimes Google Sheets can struggle with import XML resulting to N/A values.
+ */
+declare const isCellNa: ({ input }: {
+    input: any;
+}) => boolean;
+export default isCellNa;

package/google/sheets/isCellNa.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Noticed sometimes Google Sheets can struggle with import XML resulting to N/A values.
+ */
+const isCellNa = ({ input }) => '#N/A' === input;
+exports.default = isCellNa;

package/google/storage/copyToCloud.d.ts

@@ -0,0 +1,11 @@
+type CopyToCloud = {
+    bucket: string;
+    localFile: string;
+    options?: object;
+    projectId?: string;
+};
+/**
+ * Copy a local file to Google Cloud Storage.
+ */
+export declare const copyToCloud: ({ bucket, localFile, options, projectId }: CopyToCloud) => Promise<any>;
+export default copyToCloud;

package/google/storage/copyToCloud.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyToCloud = void 0;
+const getClient_1 = __importDefault(require("./getClient"));
+/**
+ * Copy a local file to Google Cloud Storage.
+ */
+const copyToCloud = async ({ bucket, localFile, options, projectId }) => {
+    const bucketInstance = (0, getClient_1.default)({ projectId })
+        .bucket(bucket);
+    const apiResponse = await bucketInstance.upload(localFile, options);
+    return apiResponse;
+};
+exports.copyToCloud = copyToCloud;
+exports.default = exports.copyToCloud;

package/google/storage/getClient.d.ts

@@ -0,0 +1,8 @@
+type GetClient = {
+    projectId?: string;
+};
+/**
+ * Create a new client if the project id differs from the global.
+ */
+declare const getClient: ({ projectId }: GetClient) => any;
+export default getClient;

package/google/storage/getClient.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Create a new client if the project id differs from the global.
+ */
+const getClient = ({ projectId }) => {
+    let client = global.googleStorageClient;
+    if (undefined !== projectId && projectId !== global.googleStorageDefault.projectId) {
+        const { Storage } = require('@google-cloud/storage');
+        client = new Storage({
+            credentials: global.googleStorageDefault.credentials,
+            location: "europe-west2",
+            projectId: projectId,
+        });
+    }
+    return client;
+};
+exports.default = getClient;

package/google/storage/initClient.d.ts

@@ -0,0 +1,12 @@
+import { Config } from '../getConfig';
+type InitClient = {
+    parameter: Config;
+    projectId: string;
+};
+/**
+ * Initialise the Google Sheets instance using the separate service method.
+ * https://github.com/googleapis/google-api-nodejs-client
+ * Library: @googleapis/sheets
+ */
+declare const initClient: ({ parameter, projectId }: InitClient) => void;
+export default initClient;

package/google/storage/initClient.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getConfig_1 = __importDefault(require("../getConfig"));
+global.googleStorageDefault = {
+    credentials: null,
+    projectId: null,
+};
+global.googleStorageClient = null;
+/**
+ * Initialise the Google Sheets instance using the separate service method.
+ * https://github.com/googleapis/google-api-nodejs-client
+ * Library: @googleapis/sheets
+ */
+const initClient = ({ parameter, projectId }) => {
+    if (!global.googleStorageClient) {
+        const { Storage } = require('@google-cloud/storage');
+        const formattedConfig = (0, getConfig_1.default)({ parameter });
+        global.googleStorageDefault.credentials = formattedConfig;
+        global.googleStorageDefault.projectId = projectId;
+        global.googleStorageClient = new Storage({
+            credentials: formattedConfig,
+            projectId: projectId,
+        });
+    }
+};
+exports.default = initClient;

package/google/storage/isFileExists.d.ts

@@ -0,0 +1,10 @@
+type IsFileExists = {
+    bucket: string;
+    key: string;
+    projectId?: string;
+};
+/**
+ * Check to see if a file exists but don't get the contents.
+ */
+declare const isFileExists: (props: IsFileExists) => Promise<boolean>;
+export default isFileExists;

package/google/storage/isFileExists.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getClient_1 = __importDefault(require("./getClient"));
+/**
+ * Check to see if a file exists but don't get the contents.
+ */
+const isFileExists = async (props) => {
+    const { bucket, key, projectId, } = props;
+    const googleFile = await (0, getClient_1.default)({ projectId })
+        .bucket(bucket)
+        .file(key)
+        .exists();
+    const response = googleFile?.[0];
+    return response;
+};
+exports.default = isFileExists;

package/google/storage/writeFile.d.ts

@@ -0,0 +1,11 @@
+type WriteFile = {
+    bucket: string;
+    data: any;
+    key: string;
+    [options: string]: any;
+};
+/**
+ * Write a file to Google Cloud Storage.
+ */
+export declare const writeFile: (props: WriteFile) => Promise<any>;
+export default writeFile;

package/google/storage/writeFile.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFile = void 0;
+const getClient_1 = __importDefault(require("./getClient"));
+/**
+ * Write a file to Google Cloud Storage.
+ */
+const writeFile = async (props) => {
+    const { bucket, contentType, data, key, projectId, ...options } = props;
+    const stream = require("stream");
+    const dataStream = new stream.PassThrough();
+    const googleFile = (0, getClient_1.default)({ projectId })
+        .bucket(bucket)
+        .file(key);
+    dataStream.push(data);
+    dataStream.push(null);
+    return await new Promise((resolve, reject) => {
+        dataStream.pipe(googleFile.createWriteStream({
+            contentType: "auto",
+            resumable: false,
+            validation: false,
+            metadata: {},
+            ...options,
+        }))
+            .on("error", (error) => {
+            reject(error);
+        })
+            .on("finish", () => {
+            resolve(true);
+        });
+    });
+};
+exports.writeFile = writeFile;
+exports.default = exports.writeFile;

package/googleAds/getCustomer.d.ts

@@ -0,0 +1,8 @@
+type GetCustomer = {
+    customerId: string;
+};
+/**
+ * Return the Google Ads Client with the specified customer set.
+ */
+declare const getCustomer: ({ customerId }: GetCustomer) => Promise<any>;
+export default getCustomer;

package/googleAds/getCustomer.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Return the Google Ads Client with the specified customer set.
+ */
+const getCustomer = async ({ customerId }) => {
+    const customer = global.googleAdsClient.instance.Customer({
+        customer_id: customerId,
+        login_customer_id: global.googleAdsClient.mccAccountId,
+        refresh_token: global.googleAdsClient.refreshToken,
+    });
+    return customer;
+};
+exports.default = getCustomer;

package/googleAds/initClient.d.ts

@@ -0,0 +1,16 @@
+export type GoogleAdsParameter = {
+    clientId: string;
+    clientSecret: string;
+    developerToken: string;
+    mccAccountId: string;
+    refreshToken: string;
+};
+type InitClient = {
+    parameter: GoogleAdsParameter;
+};
+/**
+ * Shorthand function to get the Google Ads Client.
+ * Library: google-ads-api
+ */
+declare const initClient: ({ parameter }: InitClient) => Promise<void>;
+export default initClient;

package/googleAds/initClient.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+global.googleAdsClient = {
+    instance: null,
+    mccAccountId: '',
+    refreshToken: '',
+};
+/**
+ * Shorthand function to get the Google Ads Client.
+ * Library: google-ads-api
+ */
+const initClient = async ({ parameter }) => {
+    if (!global.googleAdsClient.instance) {
+        const { GoogleAdsApi } = require('google-ads-api');
+        // Create a new client instance
+        global.googleAdsClient.instance = new GoogleAdsApi({
+            client_id: parameter.clientId,
+            client_secret: parameter.clientSecret,
+            developer_token: parameter.developerToken,
+        });
+        global.googleAdsClient.mccAccountId = parameter.mccAccountId;
+        global.googleAdsClient.refreshToken = parameter.refreshToken;
+    }
+};
+exports.default = initClient;