@8ms/helpers 1.39.0 → 2.0.1

package/google/bigQuery/loadData.js

@@ -1,32 +1,18 @@
 "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"));
+exports.loadData = void 0;
 /**
- * Load data into a given table.
+ * Load data into a given table using Google Cloud Storage.
  */
-const loadData = async ({ file, table }) => {
-    const tableExists = await (0, IsTableExists_1.default)({
-        datasetId: table.datasetId,
-        projectId: table.projectId,
-        tableId: table.tableId,
-    });
+const loadData = async ({ file, googleBigQueryClient, googleCloudStorageClient, table }) => {
+    const tableExists = await googleBigQueryClient.tableExists(table.datasetId, table.tableId);
     if (tableExists) {
-        let bigqueryClient = (0, getClient_1.default)({
-            projectId: table.projectId
-        });
-        let storageClient = (0, getClient_2.default)({
-            projectId: file.projectId
-        });
-        await bigqueryClient
+        await googleBigQueryClient.client
             .dataset(table.datasetId)
             .table(table.tableId)
-            .load(storageClient.bucket(file.bucket)
+            .load(googleCloudStorageClient.client
+            .bucket(file.bucket)
             .file(file.key), file.metadata);
     }
 };
-exports.default = loadData;
+exports.loadData = loadData;

package/google/{getConfig.d.ts → index.d.ts}

@@ -1,4 +1,4 @@
-export type Config = {
+export type GoogleCloudConfig = {
     type: string;
     project_id: string;
     private_key_id: string;
@@ -10,11 +10,18 @@ export type Config = {
     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;
+export declare const getConfig: (parameter: GoogleCloudConfig) => {
+    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;
+};

package/google/index.js

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

package/google/sheets/GoogleSheetsNamespace.d.ts

@@ -0,0 +1,16 @@
+import { BaseNamespace } from "../../_class";
+import { GoogleCloudConfig } from "../index";
+import type { GoogleAuth } from "googleapis-common";
+type GetBatchDataProps = {
+    spreadsheetId: string;
+    ranges: string[];
+    dateTimeRender?: string;
+    valueRender?: string;
+};
+export declare class GoogleSheetsNamespace extends BaseNamespace {
+    client: GoogleAuth | null;
+    config: GoogleCloudConfig | null;
+    ensureInit: () => Promise<void>;
+    getBatchData: (props: GetBatchDataProps) => Promise<import("@googleapis/sheets").sheets_v4.Schema$BatchGetValuesResponse>;
+}
+export {};

package/google/sheets/GoogleSheetsNamespace.js

@@ -0,0 +1,81 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleSheetsNamespace = void 0;
+const _class_1 = require("../../_class");
+const index_1 = require("../index");
+class GoogleSheetsNamespace extends _class_1.BaseNamespace {
+    constructor() {
+        super(...arguments);
+        // Stores auth only for Google Sheets
+        this.client = null;
+        this.config = null;
+        this.ensureInit = async () => {
+            if (!this.client) {
+                try {
+                    const googleApisSheets = await Promise.resolve().then(() => __importStar(require("@googleapis/sheets")));
+                    const formattedConfig = (0, index_1.getConfig)(this.config);
+                    this.client = new googleApisSheets.auth.GoogleAuth({
+                        // @ts-ignore
+                        credentials: formattedConfig,
+                        scopes: [
+                            "https://www.googleapis.com/auth/spreadsheets",
+                        ],
+                    });
+                }
+                catch (e) {
+                    throw new Error("Google Sheets Client not installed");
+                }
+            }
+        };
+        this.getBatchData = async (props) => {
+            await this.ensureInit();
+            const googleApisSheets = await Promise.resolve().then(() => __importStar(require("@googleapis/sheets")));
+            // Make the API request
+            const apiResponse = await googleApisSheets.sheets("v4")
+                .spreadsheets
+                .values
+                .batchGet({
+                auth: this.client,
+                dateTimeRenderOption: props?.dateTimeRender || "FORMATTED_STRING",
+                ranges: props.ranges,
+                spreadsheetId: props.spreadsheetId,
+                valueRenderOption: props?.valueRender || "UNFORMATTED_VALUE"
+            });
+            return apiResponse.data;
+        };
+    }
+}
+exports.GoogleSheetsNamespace = GoogleSheetsNamespace;

package/google/sheets/getAssociatedData.d.ts

@@ -1,16 +1,10 @@
-type GetAssociatedData = {
-    spreadsheetId: string;
-    ranges: [
-        format: string,
-        defaultRange: string,
-        heading: string,
-        data: string
-    ];
+type GetAssociatedDataProps = {
+    data: any;
     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.
+ * Pass a batch request using getBatchData and format the data into a key => value object per row.
  */
-declare const getAssociatedData: ({ dateTimeRender, ranges, spreadsheetId, valueRender }: GetAssociatedData) => Promise<object[]>;
-export default getAssociatedData;
+export declare const getAssociatedData: (props: GetAssociatedDataProps) => Promise<object[]>;
+export {};

package/google/sheets/getAssociatedData.js

@@ -1,45 +1,35 @@
 "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"));
+exports.getAssociatedData = void 0;
 /**
- * Make a batch get to Google Sheets to retrieve the data correctly formatted, with default values provided.
+ * Pass a batch request using getBatchData and format the data into a key => value object per row.
  */
-const getAssociatedData = async ({ dateTimeRender, ranges, spreadsheetId, valueRender }) => {
-    // Make the API request
-    const apiResponse = await (0, getBatchData_1.default)({
-        spreadsheetId,
-        ranges,
-        dateTimeRender,
-        valueRender,
-    });
+const getAssociatedData = async (props) => {
     let template = [];
     let response = [];
     // Missing ranges or too many ranges
-    if (4 !== apiResponse.valueRanges.length) {
+    if (4 !== props.data.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;
+    const initialRangeLength = props.data.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],
+            format: props.data.valueRanges[0].values[0][i],
+            default: props.data.valueRanges[1].values[0][i],
+            heading: props.data.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++) {
+    if (undefined !== props.data.valueRanges[3].values) {
+        for (let rowIndex = 0; rowIndex < props.data.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];
+            for (let columnIndex = 0; columnIndex < props.data.valueRanges[3].values[rowIndex].length; columnIndex++) {
+                const refValue = props.data.valueRanges[3].values[rowIndex][columnIndex];
                 const value = ('' === refValue ? template[columnIndex]['default'] : refValue);
                 // Add this to our row
                 row[template[columnIndex]['heading']] = value;
@@ -50,4 +40,4 @@ const getAssociatedData = async ({ dateTimeRender, ranges, spreadsheetId, valueR
     }
     return response;
 };
-exports.default = getAssociatedData;
+exports.getAssociatedData = getAssociatedData;

package/google/sheets/index.d.ts

@@ -0,0 +1,8 @@
+import { GoogleSheetsNamespace } from "./GoogleSheetsNamespace";
+import type { GoogleAuthOptions } from "@google-cloud/common";
+export declare const googleSheetsAuths: (key?: string, config?: GoogleAuthOptions, vaultId?: string, itemId?: string) => Promise<GoogleSheetsNamespace>;
+/**
+ * Noticed sometimes Google Sheets can struggle with import XML resulting to N/A values.
+ */
+export declare const isCellNa: (input: any) => boolean;
+export { getAssociatedData } from "./getAssociatedData";

package/google/sheets/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssociatedData = exports.isCellNa = exports.googleSheetsAuths = void 0;
+const GoogleSheetsNamespace_1 = require("./GoogleSheetsNamespace");
+const onePassword_1 = require("../../onePassword");
+const googleSheetsNamespaces = new Map();
+const googleSheetsAuths = async (key = "default", config, vaultId, itemId) => {
+    if (googleSheetsNamespaces.has(key)) {
+        return googleSheetsNamespaces.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.GOOGLE_CLOUD_VAULT_ID && process.env.GOOGLE_CLOUD_ITEM_ID) {
+        instanceConfig = await (await (0, onePassword_1.onePasswordClient)())
+            .getJsonNote(process.env.GOOGLE_CLOUD_VAULT_ID, process.env.GOOGLE_CLOUD_ITEM_ID);
+    }
+    else {
+        throw new Error(`Config required for namespace '${key}'`);
+    }
+    const namespace = new GoogleSheetsNamespace_1.GoogleSheetsNamespace(key, instanceConfig);
+    googleSheetsNamespaces.set(key, namespace);
+    return namespace;
+};
+exports.googleSheetsAuths = googleSheetsAuths;
+/**
+ * Noticed sometimes Google Sheets can struggle with import XML resulting to N/A values.
+ */
+const isCellNa = (input) => "#N/A" === input;
+exports.isCellNa = isCellNa;
+var getAssociatedData_1 = require("./getAssociatedData");
+Object.defineProperty(exports, "getAssociatedData", { enumerable: true, get: function () { return getAssociatedData_1.getAssociatedData; } });

package/google/storage/GoogleCloudStorageNamespace.d.ts

@@ -0,0 +1,20 @@
+import { BaseNamespace } from "../../_class";
+import type { Storage } from "@google-cloud/storage";
+import { GoogleCloudConfig } from "../index";
+export declare class GoogleCloudStorageNamespace extends BaseNamespace {
+    client: Storage | null;
+    config: GoogleCloudConfig;
+    ensureInit: () => Promise<void>;
+    /**
+     * Copy a local file to Google Cloud Storage.
+     */
+    copyToCloud: (bucket: string, localFile: string, options?: {}) => Promise<import("@google-cloud/storage").UploadResponse>;
+    /**
+     * Check to see if a file exists but don't get the contents.
+     */
+    fileExists: (bucket: string, key: string) => Promise<boolean>;
+    /**
+     * Write a file to Google Cloud Storage.
+     */
+    writeFile: (bucket: string, key: string, data: any, options?: {}) => Promise<unknown>;
+}

package/google/storage/GoogleCloudStorageNamespace.js

@@ -0,0 +1,108 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleCloudStorageNamespace = void 0;
+const _class_1 = require("../../_class");
+const index_1 = require("../index");
+class GoogleCloudStorageNamespace extends _class_1.BaseNamespace {
+    constructor() {
+        super(...arguments);
+        this.client = null;
+        this.ensureInit = async () => {
+            if (!this.client) {
+                try {
+                    const { Storage } = await Promise.resolve().then(() => __importStar(require("@google-cloud/storage")));
+                    const formattedConfig = (0, index_1.getConfig)(this.config);
+                    // @ts-ignore
+                    this.client = new Storage(formattedConfig);
+                }
+                catch (e) {
+                    throw new Error("Google Cloud Storage Client not installed");
+                }
+            }
+        };
+        /**
+         * Copy a local file to Google Cloud Storage.
+         */
+        this.copyToCloud = async (bucket, localFile, options = {}) => {
+            await this.ensureInit();
+            const apiResponse = await this.client
+                .bucket(bucket)
+                .upload(localFile, options);
+            return apiResponse;
+        };
+        /**
+         * Check to see if a file exists but don't get the contents.
+         */
+        this.fileExists = async (bucket, key) => {
+            await this.ensureInit();
+            const googleFile = await this.client
+                .bucket(bucket)
+                .file(key)
+                .exists();
+            const response = googleFile?.[0];
+            return response;
+        };
+        /**
+         * Write a file to Google Cloud Storage.
+         */
+        this.writeFile = async (bucket, key, data, options = {}) => {
+            await this.ensureInit();
+            const stream = await Promise.resolve().then(() => __importStar(require("stream")));
+            const dataStream = new stream.PassThrough();
+            const googleFile = this.client
+                .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.GoogleCloudStorageNamespace = GoogleCloudStorageNamespace;

package/google/storage/index.d.ts

@@ -0,0 +1,3 @@
+import { GoogleCloudStorageNamespace } from "./GoogleCloudStorageNamespace";
+import type { GoogleAuthOptions } from "@google-cloud/common";
+export declare const googleCloudStorageClient: (key?: string, config?: GoogleAuthOptions, vaultId?: string, itemId?: string) => Promise<GoogleCloudStorageNamespace>;

package/google/storage/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.googleCloudStorageClient = void 0;
+const GoogleCloudStorageNamespace_1 = require("./GoogleCloudStorageNamespace");
+const onePassword_1 = require("../../onePassword");
+const googleCloudStorageNamespaces = new Map();
+const googleCloudStorageClient = async (key = "default", config, vaultId, itemId) => {
+    if (googleCloudStorageNamespaces.has(key)) {
+        return googleCloudStorageNamespaces.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.GOOGLE_CLOUD_VAULT_ID && process.env.GOOGLE_CLOUD_ITEM_ID) {
+        instanceConfig = await (await (0, onePassword_1.onePasswordClient)())
+            .getJsonNote(process.env.GOOGLE_CLOUD_VAULT_ID, process.env.GOOGLE_CLOUD_ITEM_ID);
+    }
+    else {
+        throw new Error(`Config required for namespace '${key}'`);
+    }
+    const namespace = new GoogleCloudStorageNamespace_1.GoogleCloudStorageNamespace(key, instanceConfig);
+    googleCloudStorageNamespaces.set(key, namespace);
+    return namespace;
+};
+exports.googleCloudStorageClient = googleCloudStorageClient;

package/googleAds/GoogleAdsNamespace.d.ts

@@ -0,0 +1,11 @@
+import { BaseNamespace } from "../_class";
+import type { GoogleAdsApi } from "google-ads-api";
+import { Config } from "./index";
+export declare class GoogleAdsNamespace extends BaseNamespace {
+    client: GoogleAdsApi | null;
+    config: Config | null;
+    mccAccountId: string;
+    refreshToken: string;
+    ensureInit: () => Promise<void>;
+    getCustomer: (customerId: string) => Promise<import("google-ads-api").Customer>;
+}

package/googleAds/GoogleAdsNamespace.js

@@ -0,0 +1,73 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleAdsNamespace = void 0;
+const _class_1 = require("../_class");
+class GoogleAdsNamespace extends _class_1.BaseNamespace {
+    constructor() {
+        super(...arguments);
+        this.client = null;
+        this.config = null;
+        this.mccAccountId = "";
+        this.refreshToken = "";
+        this.ensureInit = async () => {
+            if (!this.client) {
+                try {
+                    const { GoogleAdsApi } = await Promise.resolve().then(() => __importStar(require("google-ads-api")));
+                    this.client = new GoogleAdsApi({
+                        client_id: this.config.client.clientId,
+                        client_secret: this.config.client.clientSecret,
+                        developer_token: this.config.client.developerToken,
+                    });
+                    this.mccAccountId = this.config.mccAccountId;
+                    this.refreshToken = this.config.refreshToken;
+                }
+                catch (e) {
+                    throw new Error("Google Sheets Client not installed");
+                }
+            }
+        };
+        this.getCustomer = async (customerId) => {
+            await this.ensureInit();
+            const customer = this.client.Customer({
+                customer_id: customerId,
+                login_customer_id: global.googleAdsClient.mccAccountId,
+                refresh_token: global.googleAdsClient.refreshToken,
+            });
+            return customer;
+        };
+    }
+}
+exports.GoogleAdsNamespace = GoogleAdsNamespace;

package/googleAds/index.d.ts

@@ -0,0 +1,11 @@
+import { GoogleAdsNamespace } from "./GoogleAdsNamespace";
+export type Config = {
+    client: {
+        clientId: string;
+        clientSecret: string;
+        developerToken: string;
+    };
+    mccAccountId: string;
+    refreshToken: string;
+};
+export declare const googleAdsClient: (key?: string, config?: Config, vaultId?: string, itemId?: string) => Promise<GoogleAdsNamespace>;

package/googleAds/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.googleAdsClient = void 0;
+const GoogleAdsNamespace_1 = require("./GoogleAdsNamespace");
+const onePassword_1 = require("../onePassword");
+const googleAdsNamespaces = new Map();
+const googleAdsClient = async (key = "default", config, vaultId, itemId) => {
+    if (googleAdsNamespaces.has(key)) {
+        return googleAdsNamespaces.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.GOOGLE_ADS_VAULT_ID && process.env.GOOGLE_ADS_ITEM_ID) {
+        instanceConfig = await (await (0, onePassword_1.onePasswordClient)())
+            .getJsonNote(process.env.GOOGLE_ADS_VAULT_ID, process.env.GOOGLE_ADS_ITEM_ID);
+    }
+    else {
+        throw new Error(`Config required for namespace '${key}'`);
+    }
+    const namespace = new GoogleAdsNamespace_1.GoogleAdsNamespace(key, instanceConfig);
+    googleAdsNamespaces.set(key, namespace);
+    return namespace;
+};
+exports.googleAdsClient = googleAdsClient;