@8ms/helpers 1.41.1 → 1.42.0

package/dist/esm/google/bigQuery/IsTableExists.js

@@ -0,0 +1,20 @@
+import getClient from "./getClient";
+/**
+ * Check to see whether a given BigQuery table exists.
+ * https://cloud.google.com/bigquery/docs/samples/bigquery-table-exists
+ */
+const isTableExists = async ({ datasetId, projectId, tableId }) => {
+    let response;
+    let client = getClient({ projectId });
+    const dataset = client.dataset(datasetId);
+    try {
+        await dataset.table(tableId)
+            .get();
+        response = true;
+    }
+    catch (exception) {
+        response = false;
+    }
+    return response;
+};
+export default isTableExists;

package/dist/esm/google/bigQuery/createDataset.d.ts

@@ -0,0 +1,11 @@
+type CreateDataset = {
+    datasetId: string;
+    projectId?: string;
+    options: object;
+};
+/**
+ * Create a Dataset if it doesn't already exist.
+ * Returns table instance.
+ */
+declare const createDataset: ({ datasetId, options, projectId }: CreateDataset) => Promise<void>;
+export default createDataset;

package/dist/esm/google/bigQuery/createDataset.js

@@ -0,0 +1,17 @@
+import getClient from "./getClient";
+import isDatasetExists from "./isDatasetExists";
+/**
+ * Create a Dataset if it doesn't already exist.
+ * Returns table instance.
+ */
+const createDataset = async ({ datasetId, options, projectId }) => {
+    const datasetExists = await isDatasetExists({
+        datasetId,
+        projectId,
+    });
+    if (!datasetExists) {
+        let client = getClient({ projectId });
+        await client.createDataset(datasetId, options || {});
+    }
+};
+export default createDataset;

package/dist/esm/google/bigQuery/createTable.d.ts

@@ -0,0 +1,12 @@
+type CreateTable = {
+    datasetId: string;
+    datasetOptions?: object;
+    projectId?: string;
+    options?: object;
+    tableId: string;
+};
+/**
+ * Create a Table if it doesn't already exist.
+ */
+declare const createTable: ({ datasetId, datasetOptions, options, projectId, tableId }: CreateTable) => Promise<void>;
+export default createTable;

package/dist/esm/google/bigQuery/createTable.js

@@ -0,0 +1,26 @@
+import isTableExists from './IsTableExists';
+import getClient from "./getClient";
+import createDataset from "./createDataset";
+/**
+ * Create a Table if it doesn't already exist.
+ */
+const createTable = async ({ datasetId, datasetOptions, options, projectId, tableId }) => {
+    // Create the BigQuery table if it doesn't exist
+    await createDataset({
+        datasetId,
+        options: datasetOptions,
+        projectId,
+    });
+    const tableExists = await isTableExists({
+        datasetId,
+        projectId,
+        tableId
+    });
+    if (!tableExists) {
+        let client = getClient({ projectId });
+        await client
+            .dataset(datasetId)
+            .createTable(tableId, options || {});
+    }
+};
+export default createTable;

package/dist/esm/google/bigQuery/getClient.d.ts

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

package/dist/esm/google/bigQuery/getClient.js

@@ -0,0 +1,16 @@
+/**
+ * Create a new client if the project id differs from the global.
+ */
+const getClient = (props) => {
+    let client = global.googleBigQueryClient;
+    if (props?.projectId && props?.projectId !== global.googleBigQueryDefaultProjectId) {
+        const { BigQuery } = require('@google-cloud/bigquery');
+        client = new BigQuery({
+            credentials: global.googleBigQueryDefault.credentials,
+            location: props?.location || "europe-west2",
+            projectId: props?.projectId,
+        });
+    }
+    return client;
+};
+export default getClient;

package/dist/esm/google/bigQuery/getDatasets.d.ts

@@ -0,0 +1,13 @@
+type GetDatasets = {
+    projectId?: string;
+};
+type Datasets = {
+    id: string;
+    location: string;
+    projectId: string;
+};
+/**
+ * Retrieve all the Datasets from a given Project.
+ */
+declare const getDatasets: ({ projectId }: GetDatasets) => Promise<Datasets[]>;
+export default getDatasets;

package/dist/esm/google/bigQuery/getDatasets.js

@@ -0,0 +1,22 @@
+import getClient from './getClient';
+/**
+ * Retrieve all the Datasets from a given Project.
+ */
+const getDatasets = async ({ projectId }) => {
+    let response = [];
+    const client = getClient({
+        projectId,
+    });
+    const datasets = await client.getDatasets();
+    if (datasets?.[0]) {
+        for (let i = 0; i < datasets[0].length; i++) {
+            response.push({
+                id: datasets[0][i].id,
+                location: datasets[0][i].location,
+                projectId: datasets[0][i].bigQuery.projectId,
+            });
+        }
+    }
+    return response;
+};
+export default getDatasets;

package/dist/esm/google/bigQuery/getTables.d.ts

@@ -0,0 +1,12 @@
+type GetTables = {
+    datasetId?: string;
+    projectId?: string;
+};
+type Tables = {
+    id: string;
+};
+/**
+ * Retrieve all the Tables from a given Project/Dataset.
+ */
+declare const getTables: (props: GetTables) => Promise<Tables[]>;
+export default getTables;

package/dist/esm/google/bigQuery/getTables.js

@@ -0,0 +1,20 @@
+import getClient from './getClient';
+/**
+ * Retrieve all the Tables from a given Project/Dataset.
+ */
+const getTables = async (props) => {
+    let response = [];
+    const client = getClient({
+        projectId: props.projectId,
+    });
+    const tables = await client.dataset(props.datasetId).getTables();
+    if (tables?.[0]) {
+        for (let i = 0; i < tables[0].length; i++) {
+            response.push({
+                id: tables[0][i].id,
+            });
+        }
+    }
+    return response;
+};
+export default getTables;

package/dist/esm/google/bigQuery/initClient.d.ts

@@ -0,0 +1,11 @@
+import { Config } from '../getConfig';
+type InitClient = {
+    parameter: Config;
+    projectId: string;
+};
+/**
+ * Initialise the Big Query client.
+ * It's possible to use multiple clients, so we set one up per project id.
+ */
+declare const initClient: ({ parameter, projectId }: InitClient) => void;
+export default initClient;

package/dist/esm/google/bigQuery/initClient.js

@@ -0,0 +1,24 @@
+import getConfig from '../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 = getConfig({ parameter });
+        global.googleBigQueryDefault.credentials = formattedConfig;
+        global.googleBigQueryDefault.projectId = projectId;
+        global.googleBigQueryClient = new BigQuery({
+            credentials: global.googleBigQueryDefault.credentials,
+            location: "europe-west2",
+            projectId: global.googleBigQueryDefault.projectId,
+        });
+    }
+};
+export default initClient;

package/dist/esm/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/dist/esm/google/bigQuery/isDatasetExists.js

@@ -0,0 +1,20 @@
+import getClient from "./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 = getClient({ projectId });
+    try {
+        await client.dataset(datasetId)
+            .get();
+        response = true;
+    }
+    catch (exception) {
+        response = false;
+    }
+    return response;
+};
+export default isDatasetExists;

package/dist/esm/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/dist/esm/google/bigQuery/loadData.js

@@ -0,0 +1,27 @@
+import isTableExists from './IsTableExists';
+import getBigqueryClient from "./getClient";
+import getStorageClient from "../storage/getClient";
+/**
+ * Load data into a given table.
+ */
+const loadData = async ({ file, table }) => {
+    const tableExists = await isTableExists({
+        datasetId: table.datasetId,
+        projectId: table.projectId,
+        tableId: table.tableId,
+    });
+    if (tableExists) {
+        let bigqueryClient = getBigqueryClient({
+            projectId: table.projectId
+        });
+        let storageClient = getStorageClient({
+            projectId: file.projectId
+        });
+        await bigqueryClient
+            .dataset(table.datasetId)
+            .table(table.tableId)
+            .load(storageClient.bucket(file.bucket)
+            .file(file.key), file.metadata);
+    }
+};
+export default loadData;

package/dist/esm/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/dist/esm/google/bigQuery/query.js

@@ -0,0 +1,10 @@
+import getClient from "./getClient";
+/**
+ * Build the query and return the data.
+ */
+const query = async ({ input, projectId }) => {
+    let client = getClient({ projectId });
+    const apiResponse = await client.query(input);
+    return apiResponse;
+};
+export default query;

package/dist/esm/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/dist/esm/google/getConfig.js

@@ -0,0 +1,21 @@
+/**
+ * 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;
+};
+export default getConfig;

package/dist/esm/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/dist/esm/google/sheets/getAssociatedData.js

@@ -0,0 +1,48 @@
+import getBatchData from './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 getBatchData({
+        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;
+};
+export default getAssociatedData;

package/dist/esm/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/dist/esm/google/sheets/getBatchData.js

@@ -0,0 +1,17 @@
+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;
+};
+export default getBatchData;

package/dist/esm/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/dist/esm/google/sheets/initClient.js

@@ -0,0 +1,20 @@
+import getConfig from '../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 = getConfig({ parameter });
+        global.googleSheetsClient = new googleApisSheets.auth.GoogleAuth({
+            credentials: formattedConfig,
+            scopes: [
+                'https://www.googleapis.com/auth/spreadsheets',
+            ],
+        });
+    }
+};
+export default initClient;

package/dist/esm/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/dist/esm/google/sheets/isCellNa.js

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

package/dist/esm/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/dist/esm/google/storage/copyToCloud.js

@@ -0,0 +1,11 @@
+import getClient from "./getClient";
+/**
+ * Copy a local file to Google Cloud Storage.
+ */
+export const copyToCloud = async ({ bucket, localFile, options, projectId }) => {
+    const bucketInstance = getClient({ projectId })
+        .bucket(bucket);
+    const apiResponse = await bucketInstance.upload(localFile, options);
+    return apiResponse;
+};
+export default copyToCloud;

package/dist/esm/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/dist/esm/google/storage/getClient.js

@@ -0,0 +1,16 @@
+/**
+ * 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;
+};
+export default getClient;

package/dist/esm/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/dist/esm/google/storage/initClient.js

@@ -0,0 +1,24 @@
+import getConfig from '../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 = getConfig({ parameter });
+        global.googleStorageDefault.credentials = formattedConfig;
+        global.googleStorageDefault.projectId = projectId;
+        global.googleStorageClient = new Storage({
+            credentials: formattedConfig,
+            projectId: projectId,
+        });
+    }
+};
+export default initClient;

package/dist/esm/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/dist/esm/google/storage/isFileExists.js

@@ -0,0 +1,14 @@
+import getClient from "./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 getClient({ projectId })
+        .bucket(bucket)
+        .file(key)
+        .exists();
+    const response = googleFile?.[0];
+    return response;
+};
+export default isFileExists;