@8ms/helpers 2.0.0 → 2.0.1

package/google/bigQuery/GoogleBigQueryNamespace.js

@@ -0,0 +1,165 @@
+"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.GoogleBigQueryNamespace = void 0;
+const _class_1 = require("../../_class");
+const index_1 = require("../index");
+class GoogleBigQueryNamespace extends _class_1.BaseNamespace {
+    constructor() {
+        super(...arguments);
+        this.client = null;
+        this.ensureInit = async () => {
+            if (!this.client) {
+                try {
+                    const { BigQuery } = await Promise.resolve().then(() => __importStar(require("@google-cloud/bigquery")));
+                    const formattedConfig = (0, index_1.getConfig)(this.config);
+                    // @ts-ignore
+                    this.client = new BigQuery(formattedConfig);
+                }
+                catch (e) {
+                    throw new Error("Google BigQuery Client not installed");
+                }
+            }
+        };
+        /**
+         * Create a Dataset if it doesn't already exist.
+         * Returns table instance.
+         */
+        this.createDataset = async (datasetId, options = {}) => {
+            await this.ensureInit();
+            const datasetExists = await this.datasetExists(datasetId);
+            if (!datasetExists) {
+                await this.client.createDataset(datasetId, options || {});
+            }
+        };
+        /**
+         * Check to see whether a given BigQuery dataset exists.
+         * Based off:
+         * https://github.com/googleapis/nodejs-bigquery/blob/main/samples/getDataset.js
+         */
+        this.datasetExists = async (datasetId) => {
+            await this.ensureInit();
+            let response;
+            try {
+                await this.client.dataset(datasetId)
+                    .get();
+                response = true;
+            }
+            catch (exception) {
+                response = false;
+            }
+            return response;
+        };
+        /**
+         * Retrieve all the Datasets
+         */
+        this.getDataset = async () => {
+            await this.ensureInit();
+            let response = [];
+            const datasets = await this.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;
+        };
+        this.query = async (props) => {
+            await this.ensureInit();
+            let queryString = "string" === typeof props ? props : props.query;
+            let options = "string" === typeof props ? {} : props?.params;
+            const apiResponse = await this.client.query({
+                query: queryString,
+                // @ts-ignore
+                options,
+            });
+            return apiResponse;
+        };
+        /**
+         * Create a Table if it doesn't already exist.
+         */
+        this.createTable = async (datasetId, datasetOptions = {}, tableId, options = {}) => {
+            await this.ensureInit();
+            // Create the BigQuery table if it doesn't exist
+            await this.createDataset(datasetId, datasetOptions);
+            const tableExists = await this.tableExists(datasetId, tableId);
+            if (!tableExists) {
+                await this.client
+                    .dataset(datasetId)
+                    .createTable(tableId, options || {});
+            }
+        };
+        /**
+         * Check to see whether a given BigQuery table exists.
+         * https://cloud.google.com/bigquery/docs/samples/bigquery-table-exists
+         */
+        this.tableExists = async (datasetId, tableId) => {
+            await this.ensureInit();
+            let response;
+            const dataset = this.client.dataset(datasetId);
+            try {
+                await dataset.table(tableId)
+                    .get();
+                response = true;
+            }
+            catch (exception) {
+                response = false;
+            }
+            return response;
+        };
+        /**
+         * Retrieve all the Tables from a given Project/Dataset.
+         */
+        this.getTable = async (datasetId) => {
+            await this.ensureInit();
+            let response = [];
+            const tables = await this.client.dataset(datasetId)
+                .getTables();
+            if (tables?.[0]) {
+                for (let i = 0; i < tables[0].length; i++) {
+                    response.push({
+                        id: tables[0][i].id,
+                    });
+                }
+            }
+            return response;
+        };
+    }
+}
+exports.GoogleBigQueryNamespace = GoogleBigQueryNamespace;

package/google/bigQuery/index.d.ts

@@ -0,0 +1,5 @@
+import { GoogleBigQueryNamespace } from "./GoogleBigQueryNamespace";
+import type { GoogleAuthOptions } from "@google-cloud/common";
+export declare const googleBigQueryClient: (key?: string, config?: GoogleAuthOptions, vaultId?: string, itemId?: string) => Promise<GoogleBigQueryNamespace>;
+export declare const getHandlerPath: (input: string) => string;
+export { loadData } from "./loadData";

package/google/bigQuery/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadData = exports.getHandlerPath = exports.googleBigQueryClient = void 0;
+const GoogleBigQueryNamespace_1 = require("./GoogleBigQueryNamespace");
+const onePassword_1 = require("../../onePassword");
+const googleBigQueryNamespaces = new Map();
+const googleBigQueryClient = async (key = "default", config, vaultId, itemId) => {
+    if (googleBigQueryNamespaces.has(key)) {
+        return googleBigQueryNamespaces.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 GoogleBigQueryNamespace_1.GoogleBigQueryNamespace(key, instanceConfig);
+    googleBigQueryNamespaces.set(key, namespace);
+    return namespace;
+};
+exports.googleBigQueryClient = googleBigQueryClient;
+const getHandlerPath = (input) => {
+    return `${input.split(process.cwd())[1].substring(1)
+        .replace(/\\/g, "/")}`;
+};
+exports.getHandlerPath = getHandlerPath;
+var loadData_1 = require("./loadData");
+Object.defineProperty(exports, "loadData", { enumerable: true, get: function () { return loadData_1.loadData; } });

package/google/bigQuery/loadData.d.ts

@@ -0,0 +1,19 @@
+import { GoogleBigQueryNamespace } from "./GoogleBigQueryNamespace";
+type LoadData = {
+    googleBigQueryClient: GoogleBigQueryNamespace;
+    googleCloudStorageClient: any;
+    file: {
+        bucket: string;
+        key: string;
+        metadata: object;
+    };
+    table: {
+        datasetId: string;
+        tableId: string;
+    };
+};
+/**
+ * Load data into a given table using Google Cloud Storage.
+ */
+export declare const loadData: ({ file, googleBigQueryClient, googleCloudStorageClient, table }: LoadData) => Promise<void>;
+export {};

package/google/bigQuery/loadData.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadData = void 0;
+/**
+ * Load data into a given table using Google Cloud Storage.
+ */
+const loadData = async ({ file, googleBigQueryClient, googleCloudStorageClient, table }) => {
+    const tableExists = await googleBigQueryClient.tableExists(table.datasetId, table.tableId);
+    if (tableExists) {
+        await googleBigQueryClient.client
+            .dataset(table.datasetId)
+            .table(table.tableId)
+            .load(googleCloudStorageClient.client
+            .bucket(file.bucket)
+            .file(file.key), file.metadata);
+    }
+};
+exports.loadData = loadData;

package/google/index.d.ts

@@ -0,0 +1,27 @@
+export type 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;
+};
+/**
+ * Using the response from Parameter Store and format it ready to be used with Google API.
+ */
+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

@@ -0,0 +1,10 @@
+type GetAssociatedDataProps = {
+    data: any;
+    dateTimeRender: 'FORMATTED_STRING' | 'SERIAL_NUMBER';
+    valueRender: 'FORMATTED_VALUE' | 'UNFORMATTED_VALUE' | 'FORMULA';
+};
+/**
+ * Pass a batch request using getBatchData and format the data into a key => value object per row.
+ */
+export declare const getAssociatedData: (props: GetAssociatedDataProps) => Promise<object[]>;
+export {};

package/google/sheets/getAssociatedData.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssociatedData = void 0;
+/**
+ * Pass a batch request using getBatchData and format the data into a key => value object per row.
+ */
+const getAssociatedData = async (props) => {
+    let template = [];
+    let response = [];
+    // Missing ranges or too many ranges
+    if (4 !== props.data.valueRanges.length) {
+        throw new Error("Associated data response length must be 4.");
+    }
+    // Get the first data range
+    const initialRangeLength = props.data.valueRanges[0].values[0].length;
+    // Loop through the headings
+    for (let i = 0; i < initialRangeLength; i++) {
+        template.push({
+            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 !== 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 < 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;
+            }
+            // Add the row to our response
+            response.push(row);
+        }
+    }
+    return response;
+};
+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;