@owox/connectors 0.12.0-next-20251105102829 → 0.12.0-next-20251105123137

package/dist/index.js

@@ -25,11 +25,6 @@ var require_index = __commonJS({
       SERVER_ERROR_MIN: 500,
       SERVER_ERROR_MAX: 599
     };
-    var ENVIRONMENT = {
-      UNKNOWN: 1,
-      APPS_SCRIPT: 2,
-      NODE: 3
-    };
     var EXECUTION_STATUS = {
       IMPORT_IN_PROGRESS: 1,
       CLEANUP_IN_PROGRESS: 2,
@@ -77,269 +72,11 @@ var require_index = __commonJS({
     }
     class UnsupportedEnvironmentException extends AbstractException {
     }
-    var EnvironmentAdapter = class EnvironmentAdapter {
-      /**
-       * Mac algorithm constants.
-       * 
-       * @type {Object}
-       */
-      static get MacAlgorithm() {
-        return {
-          HMAC_SHA_256: "HMAC_SHA_256",
-          HMAC_SHA_384: "HMAC_SHA_384",
-          HMAC_SHA_512: "HMAC_SHA_512",
-          HMAC_SHA_1: "HMAC_SHA_1",
-          HMAC_MD5: "HMAC_MD5"
-        };
-      }
-      constructor() {
-        this.environment = this.getEnvironment();
-      }
-      /**
-       * Get the current environment.
-       * Detects whether code is running in Google Apps Script or Node.js environment.
-       * 
-       * @returns {ENVIRONMENT} The detected environment (APPS_SCRIPT, NODE, or UNKNOWN)
-       * @throws {UnsupportedEnvironmentException} If environment cannot be determined
-       */
-      static getEnvironment() {
-        if (typeof this.environment !== "undefined") {
-          return this.environment;
-        }
-        if (typeof UrlFetchApp !== "undefined") {
-          this.environment = ENVIRONMENT.APPS_SCRIPT;
-        } else if (typeof process !== "undefined") {
-          this.environment = ENVIRONMENT.NODE;
-        } else {
-          this.environment = ENVIRONMENT.UNKNOWN;
-        }
-        return this.environment;
-      }
-      /**
-       * Fetch data from the given URL. 
-       * 
-       * @param {string} url - The URL to fetch data from.
-       * @param {Object} options - Options for the fetch request.
-       * @returns {FetchResponse}
-       * 
-       * @throws {UnsupportedEnvironmentException} If the environment is not supported.
-       */
-      static fetch(url, options = {}) {
-        const env = this.getEnvironment();
-        if (env === ENVIRONMENT.APPS_SCRIPT) {
-          const response = UrlFetchApp.fetch(url, options);
-          return this._wrapAppsScriptResponse(response);
-        }
-        if (env === ENVIRONMENT.NODE) {
-          const method = options.method || "GET";
-          const response = request(method, url, options);
-          return this._wrapNodeResponse(response);
-        }
-        throw new UnsupportedEnvironmentException("Unsupported environment");
-      }
-      /**
-       * Sleep for the given number of milliseconds.
-       * 
-       * @param {number} ms - The number of milliseconds to sleep.
-       * @throws {UnsupportedEnvironmentException} If the environment is not supported.
-       */
-      static sleep(ms) {
-        if (this.getEnvironment() === ENVIRONMENT.APPS_SCRIPT) {
-          Utilities.sleep(ms);
-        } else if (this.getEnvironment() === ENVIRONMENT.NODE) {
-          let done = false;
-          new Promise((resolve) => {
-            setTimeout(() => {
-              done = true;
-              resolve();
-            }, ms);
-          });
-          deasync.loopWhile(() => !done);
-        } else {
-          throw new UnsupportedEnvironmentException("Unsupported environment");
-        }
-      }
-      /**
-       * Format the given date.
-       * 
-       * @param {Date} date - The date to format.
-       * @param {string} timezone - The timezone to format the date in. 
-       * @param {string} format - The format to format the date in.
-       * @returns {string}
-       * 
-       * @throws {UnsupportedEnvironmentException} If the environment is not supported.
-       */
-      static formatDate(date, timezone, format) {
-        if (this.getEnvironment() === ENVIRONMENT.APPS_SCRIPT) {
-          return Utilities.formatDate(date, timezone, format);
-        } else if (this.getEnvironment() === ENVIRONMENT.NODE) {
-          return date.toISOString().split("T")[0];
-        } else {
-          throw new UnsupportedEnvironmentException("Unsupported environment");
-        }
-      }
-      /**
-       * Get a UUID. Format: `${string}-${string}-${string}-${string}-${string}`
-       * 
-       * @returns {string} UUID
-       * 
-       * @throws {UnsupportedEnvironmentException} If the environment is not supported.
-       */
-      static getUuid() {
-        if (this.getEnvironment() === ENVIRONMENT.APPS_SCRIPT) {
-          return Utilities.getUuid();
-        } else if (this.getEnvironment() === ENVIRONMENT.NODE) {
-          const crypto = require("node:crypto");
-          return crypto.randomUUID();
-        } else {
-          throw new UnsupportedEnvironmentException("Unsupported environment");
-        }
-      }
-      /**
-       * Encode the given data to base64.
-       * 
-       * @param {string} data - The data to encode.
-       * @returns {string}
-       * 
-       * @throws {UnsupportedEnvironmentException} If the environment is not supported.
-       */
-      static base64Encode(data) {
-        if (this.getEnvironment() === ENVIRONMENT.APPS_SCRIPT) {
-          return Utilities.base64Encode(data);
-        } else if (this.getEnvironment() === ENVIRONMENT.NODE) {
-          return Buffer.from(data).toString("base64");
-        } else {
-          throw new UnsupportedEnvironmentException("Unsupported environment");
-        }
-      }
-      /**
-       * Compute the HMAC signature for the given data.
-       * 
-       * @param {string} algorithm - The algorithm to use.
-       * @param {string} data - The data to compute the signature for.
-       * @param {string} key - The key to use.
-       * @returns {string}
-       * 
-       * @throws {UnsupportedEnvironmentException} If the environment is not supported.
-       */
-      static computeHmacSignature(algorithm, data, key) {
-        if (this.getEnvironment() === ENVIRONMENT.APPS_SCRIPT) {
-          if (typeof algorithm === "string") {
-            algorithm = Utilities.MacAlgorithm[algorithm];
-          }
-          return Utilities.computeHmacSignature(algorithm, data, key);
-        } else if (this.getEnvironment() === ENVIRONMENT.NODE) {
-          const crypto = require("node:crypto");
-          const algorithmMap = {
-            "HMAC_SHA_256": "sha256",
-            "HMAC_SHA_384": "sha384",
-            "HMAC_SHA_512": "sha512",
-            "HMAC_SHA_1": "sha1",
-            "HMAC_MD5": "md5"
-          };
-          const nodeAlgorithm = algorithmMap[algorithm] || algorithm.toLowerCase().replace("hmac_", "");
-          const buffer = crypto.createHmac(nodeAlgorithm, key).update(data).digest();
-          return Array.from(buffer);
-        } else {
-          throw new UnsupportedEnvironmentException("Unsupported environment");
-        }
-      }
-      /**
-       * Parse CSV string into array of arrays
-       * 
-       * @param {string} csvString - The CSV string to parse
-       * @param {string} [delimiter=','] - The delimiter to use for parsing CSV
-       * @returns {Array<Array<string>>} Parsed CSV data
-       * @throws {UnsupportedEnvironmentException} If the environment is not supported
-       */
-      static parseCsv(csvString, delimiter = ",") {
-        if (this.getEnvironment() === ENVIRONMENT.APPS_SCRIPT) {
-          return Utilities.parseCsv(csvString, delimiter);
-        } else if (this.getEnvironment() === ENVIRONMENT.NODE) {
-          return csvString.split("\n").filter((line) => line.trim() !== "").map((line) => line.split(delimiter).map((cell) => {
-            const trimmed = cell.trim();
-            if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
-              return trimmed.slice(1, -1).replace(/""/g, '"');
-            }
-            return trimmed;
-          }));
-        } else {
-          throw new UnsupportedEnvironmentException("Unsupported environment");
-        }
-      }
-      /**
-       * Unzip a blob/buffer
-       * 
-       * @param {Blob|Buffer} data - The data to unzip
-       * @returns {Array<{getDataAsString: Function}>} Array of file-like objects with getDataAsString method
-       * @throws {UnsupportedEnvironmentException} If the environment is not supported
-       */
-      static unzip(data) {
-        if (this.getEnvironment() === ENVIRONMENT.APPS_SCRIPT) {
-          return Utilities.unzip(data);
-        } else if (this.getEnvironment() === ENVIRONMENT.NODE) {
-          const zip = new AdmZip(data);
-          return zip.getEntries().map((entry) => ({
-            getDataAsString: () => entry.getData().toString("utf8")
-          }));
-        } else {
-          throw new UnsupportedEnvironmentException("Unsupported environment");
-        }
-      }
-      /**
-       * Wraps the response from the Apps Script environment.
-       * Not use directly, only for internal purposes.
-       * 
-       * @param {Object} response
-       * @returns {FetchResponse}
-       */
-      static _wrapAppsScriptResponse(response) {
-        return {
-          getHeaders: () => response.getAllHeaders(),
-          getAsJson: () => {
-            try {
-              return JSON.parse(response.getContentText());
-            } catch (e) {
-              throw new Error("Invalid JSON response");
-            }
-          },
-          getContent: () => response.getContent(),
-          getContentText: () => response.getContentText(),
-          getBlob: () => response.getBlob(),
-          getResponseCode: () => response.getResponseCode()
-        };
-      }
-      /**
-       * Wraps the response from the Node environment.
-       * Not use directly, only for internal purposes.
-       * 
-       * @param {Object} response
-       * @returns {FetchResponse}
-       */
-      static _wrapNodeResponse(response) {
-        const headers = response.headers || {};
-        const text = response.body ? response.body.toString() : "";
-        return {
-          getHeaders: () => headers,
-          getAsJson: () => {
-            try {
-              return JSON.parse(text);
-            } catch (e) {
-              throw new Error("Invalid JSON response");
-            }
-          },
-          getContent: () => text,
-          getContentText: () => text,
-          getBlob: () => response.body,
-          getResponseCode: () => response.statusCode
-        };
-      }
-    };
     class AbstractStorage {
       //---- constructor -------------------------------------------------
       /**
-       * Asbstract class making Google Sheets data active in Apps Script to simplity read/write operations
-       * @param config (object) instance of Sheet
+       * Abstract class for storage operations providing common methods for data persistence
+       * @param config (object) instance of AbstractConfig
        * @param uniqueKeyColumns (mixed) a name of column with unique key or array with columns names
        * @param schema (object) object with structure like {fieldName: {type: "number", description: "smth" } }
        * @param description (string) string with storage description }
@@ -363,6 +100,14 @@ var require_index = __commonJS({
         }
       }
       //----------------------------------------------------------------
+      //---- init --------------------------------------------------------
+      /**
+       * Initializing storage
+       */
+      async init() {
+        throw new Error("Method init() has to be implemented in a child class of AbstractStorage");
+      }
+      //----------------------------------------------------------------
       //---- getUniqueKeyByRecordFields ----------------------------------
       /**
        * Calculcating unique key based on this.uniqueKeyColumns
@@ -419,11 +164,12 @@ var require_index = __commonJS({
       //----------------------------------------------------------------  
       //---- saveData ----------------------------------------------------
       /**
-       * Saving data to a storage. Has to be implemented in 
+       * Saving data to a storage. Has to be implemented in child class as async method.
        * @param {data} array of assoc objects with records to save
+       * @returns {Promise<void>}
        */
-      saveData(data) {
-        throw new Error("Method saveDate() has to be implemented in a child class of AbstractStorage");
+      async saveData(data) {
+        throw new Error("Method saveData() has to be implemented in a child class of AbstractStorage");
       }
       //----------------------------------------------------------------
       //---- saveRecordsAddedToBuffer ------------------------------------
@@ -494,16 +240,6 @@ var require_index = __commonJS({
         return record;
       }
       //----------------------------------------------------------------
-      //---- areHeadersNeeded --------------------------------------------
-      /**
-       * Checks if storage needs headers to be added
-       * By default returns false, should be overridden in child classes if needed
-       * @returns {boolean} true if headers need to be added, false otherwise
-       */
-      areHeadersNeeded() {
-        return false;
-      }
-      //----------------------------------------------------------------
       //---- getSelectedFields -------------------------------------------
       /**
        * Parse Fields config value and return array of selected field names
@@ -557,7 +293,7 @@ var require_index = __commonJS({
        * A Data Source-specific methid is used to fetch new data and return it as an array of objects, where each property of an object corresponds to a column name.
        * @return data array
        */
-      fetchData() {
+      async fetchData() {
         throw new Error("Method fetchData must be implemented in Class inheritor of AbstractSource");
       }
       //----------------------------------------------------------------
@@ -582,16 +318,16 @@ var require_index = __commonJS({
        * @return {HTTPResponse} The response object from the fetch
        * @throws {HttpRequestException} After exhausting all retries
        */
-      urlFetchWithRetry(url, options) {
+      async urlFetchWithRetry(url, options) {
         for (let attempt = 1; attempt <= this.config.MaxFetchRetries.value; attempt++) {
           try {
-            const response = EnvironmentAdapter.fetch(url, { ...options, muteHttpExceptions: true });
-            return this._validateResponse(response);
+            const response = await HttpUtils.fetch(url, { ...options, muteHttpExceptions: true });
+            return await this._validateResponse(response);
           } catch (error) {
             if (!this._shouldRetry(error, attempt)) {
               throw error;
             }
-            this._waitBeforeRetry(attempt);
+            await this._waitBeforeRetry(attempt);
           }
         }
       }
@@ -603,12 +339,12 @@ var require_index = __commonJS({
        * @throws {HttpRequestException} If the response indicates an error
        * @private
        */
-      _validateResponse(response) {
+      async _validateResponse(response) {
         const code = response.getResponseCode();
         if (code >= HTTP_STATUS.SUCCESS_MIN && code <= HTTP_STATUS.SUCCESS_MAX) {
           return response;
         }
-        const errorInfo = this._extractErrorInfo(response);
+        const errorInfo = await this._extractErrorInfo(response);
         throw new HttpRequestException({
           message: errorInfo.message,
           statusCode: code,
@@ -622,9 +358,9 @@ var require_index = __commonJS({
        * @return {Object} Object containing error message and JSON data if available
        * @private
        */
-      _extractErrorInfo(response) {
+      async _extractErrorInfo(response) {
         var _a, _b;
-        const text = response.getContentText();
+        const text = await response.getContentText();
         let parsedJson = null;
         let message = text;
         try {
@@ -661,10 +397,10 @@ var require_index = __commonJS({
        * @param {number} attempt - The current attempt number
        * @private
        */
-      _waitBeforeRetry(attempt) {
+      async _waitBeforeRetry(attempt) {
         const delay = this.calculateBackoff(attempt);
         console.log(`Retrying after ${Math.round(delay / 1e3)}s...`);
-        EnvironmentAdapter.sleep(delay);
+        await AsyncUtils.delay(delay);
       }
       //---- calculateBackoff --------------------------------------------
       /**
@@ -796,7 +532,7 @@ var require_index = __commonJS({
       /**
        * Initiates imports new data from a data source
        */
-      run() {
+      async run() {
         try {
           if (this.config.isInProgress()) {
             this.config.logMessage("Import is already in progress");
@@ -806,11 +542,7 @@ var require_index = __commonJS({
             this.config.handleStatusUpdate({ status: EXECUTION_STATUS.IMPORT_IN_PROGRESS });
             this.config.updateLastImportDate();
             this.config.logMessage("Start importing new data");
-            if (this.storage !== null && this.storage.areHeadersNeeded()) {
-              this.storage.addHeader(this.storage.uniqueKeyColumns);
-              this.config.logMessage(`Column(s) for unique key was added: ${this.storage.uniqueKeyColumns}`);
-            }
-            this.startImportProcess();
+            await this.startImportProcess();
             this.config.logMessage("Import is finished");
             this.config.handleStatusUpdate({
               status: EXECUTION_STATUS.IMPORT_DONE
@@ -831,7 +563,7 @@ var require_index = __commonJS({
       /**
        * A method for calling from Root script for determining parameters needed to fetch new data.
        */
-      startImportProcess() {
+      async startImportProcess() {
         var _a;
         let startDate = null;
         let endDate = /* @__PURE__ */ new Date();
@@ -842,10 +574,10 @@ var require_index = __commonJS({
           return;
         }
         endDate.setDate(startDate.getDate() + daysToFetch);
-        let data = this.source.fetchData(startDate, endDate);
+        let data = await this.source.fetchData(startDate, endDate);
         this.config.logMessage(data.length ? `${data.length} rows were fetched` : `No records have been fetched`);
         if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value) === "true") {
-          this.storage.saveData(data);
+          await this.storage.saveData(data);
         }
         if (this.runConfig.type === RUN_CONFIG_TYPE.INCREMENTAL) {
           this.config.updateLastRequstedDate(endDate);
@@ -1002,31 +734,12 @@ var require_index = __commonJS({
        * @param (object) with config data. Properties are parameters names, values are values
        */
       constructor(configData) {
-        this.addParameter("Environment", {
-          value: AbstractConfig.detectEnvironment(),
-          requiredType: "number",
-          attributes: [CONFIG_ATTRIBUTES.HIDE_IN_CONFIG_FORM, CONFIG_ATTRIBUTES.ADVANCED]
-        });
         for (var name in configData) {
           this.addParameter(name, configData[name]);
         }
         return this;
       }
       //----------------------------------------------------------------
-      //---- static helper -------------------------------------------------
-      /**
-       * Determines the runtime environment
-       * @returns {ENVIRONMENT} The detected environment
-       */
-      static detectEnvironment() {
-        if (typeof UrlFetchApp !== "undefined") {
-          return ENVIRONMENT.APPS_SCRIPT;
-        }
-        if (typeof process !== "undefined") {
-          return ENVIRONMENT.NODE;
-        }
-        return ENVIRONMENT.UNKNOWN;
-      }
       //---- mergeParameters ---------------------------------------------
       /**
        * Merge configuration to existing config
@@ -1233,11 +946,11 @@ var require_index = __commonJS({
       }
       //----------------------------------------------------------------
     }
-    function processShortLinks(data, { shortLinkField, urlFieldName }) {
+    async function processShortLinks(data, { shortLinkField, urlFieldName }) {
       if (!Array.isArray(data) || data.length === 0) return data;
       const shortLinks = _collectUniqueShortLinks(data, shortLinkField, urlFieldName);
       if (shortLinks.length === 0) return data;
-      const resolvedShortLinks = _resolveShortLinks(shortLinks);
+      const resolvedShortLinks = await _resolveShortLinks(shortLinks);
       return _populateDataWithResolvedUrls(data, resolvedShortLinks, shortLinkField, urlFieldName);
     }
     function _collectUniqueShortLinks(data, shortLinkField, urlFieldName) {
@@ -1259,13 +972,11 @@ var require_index = __commonJS({
       if (hasParams) return false;
       return /^https:\/\/[^\/]+\/[^\/]+$/.test(url);
     }
-    function _resolveShortLinks(shortLinks) {
-      return shortLinks.map((linkObj) => {
+    async function _resolveShortLinks(shortLinks) {
+      const promises = shortLinks.map(async (linkObj) => {
         try {
-          const response = EnvironmentAdapter.fetch(linkObj.originalUrl, {
-            method: "GET",
-            followRedirects: false,
-            muteHttpExceptions: true
+          const response = await HttpUtils.fetch(linkObj.originalUrl, {
+            method: "GET"
           });
           const headers = response.getHeaders();
           const resolvedUrl = headers.Location || headers.location || linkObj.originalUrl;
@@ -1281,6 +992,7 @@ var require_index = __commonJS({
           };
         }
       });
+      return Promise.all(promises);
     }
     function _populateDataWithResolvedUrls(data, resolvedShortLinks, shortLinkField, urlFieldName) {
       return data.map((record) => {
@@ -1304,15 +1016,15 @@ var require_index = __commonJS({
     var OAuthUtils = {
       /**
        * Universal OAuth access token retrieval method
-       * 
+       *
        * @param {Object} options - All configuration options
        * @param {Object} options.config - Configuration object containing credentials
        * @param {string} options.tokenUrl - OAuth token endpoint URL
        * @param {Object} options.formData - Form data to send in request body
        * @param {Object} [options.headers] - Request headers
-       * @returns {string} - The access token
+       * @returns {Promise<string>} - The access token
        */
-      getAccessToken({ config, tokenUrl, formData, headers = {} }) {
+      async getAccessToken({ config, tokenUrl, formData, headers = {} }) {
         const requestHeaders = {
           "Content-Type": "application/x-www-form-urlencoded",
           ...headers
@@ -1325,8 +1037,9 @@ var require_index = __commonJS({
           body: Object.entries(formData).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&")
         };
         try {
-          const resp = EnvironmentAdapter.fetch(tokenUrl, options);
-          const json = JSON.parse(resp.getContentText());
+          const resp = await HttpUtils.fetch(tokenUrl, options);
+          const text = await resp.getContentText();
+          const json = JSON.parse(text);
           if (json.error) {
             throw new Error(`Token error: ${json.error}`);
           }
@@ -1339,7 +1052,7 @@ var require_index = __commonJS({
       },
       /**
        * Get access token using Service Account JWT authentication
-       * 
+       *
        * @param {Object} options - Configuration options
        * @param {Object} options.config - Configuration object
        * @param {string} options.tokenUrl - Token URL
@@ -1347,7 +1060,7 @@ var require_index = __commonJS({
        * @param {string} options.scope - OAuth scope (e.g., "https://www.googleapis.com/auth/adwords")
        * @returns {string} - The access token
        */
-      getServiceAccountToken({ config, tokenUrl, serviceAccountKeyJson, scope }) {
+      async getServiceAccountToken({ config, tokenUrl, serviceAccountKeyJson, scope }) {
         try {
           const serviceAccountData = JSON.parse(serviceAccountKeyJson);
           const now = Math.floor(Date.now() / 1e3);
@@ -1365,7 +1078,7 @@ var require_index = __commonJS({
             grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
             assertion: jwt
           };
-          const accessToken = this.getAccessToken({
+          const accessToken = await this.getAccessToken({
             config,
             tokenUrl,
             formData
@@ -1418,6 +1131,68 @@ var require_index = __commonJS({
         return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
       }
     };
+    var HttpUtils = class HttpUtils {
+      /**
+       * Fetch data from the given URL.
+       *
+       * @param {string} url - The URL to fetch data from.
+       * @param {Object} options - Options for the fetch request.
+       * @returns {Promise<FetchResponse>}
+       */
+      static async fetch(url, options = {}) {
+        const method = options.method || "GET";
+        const fetchOptions = {
+          method: method.toUpperCase(),
+          headers: options.headers || {}
+        };
+        if (options.body) {
+          fetchOptions.body = options.body;
+        }
+        const response = await fetch(url, fetchOptions);
+        return this._wrapNodeResponse(response);
+      }
+      /**
+       * Wraps the response from the Node environment.
+       * Not use directly, only for internal purposes.
+       *
+       * @param {Response} response - Native fetch Response object
+       * @returns {FetchResponse}
+       */
+      static _wrapNodeResponse(response) {
+        let textCache = null;
+        let blobCache = null;
+        const getText = async () => {
+          if (textCache === null) {
+            textCache = await response.text();
+          }
+          return textCache;
+        };
+        const getBlob = async () => {
+          if (blobCache === null) {
+            blobCache = await response.arrayBuffer();
+          }
+          return Buffer.from(blobCache);
+        };
+        const headersObj = {};
+        response.headers.forEach((value, key) => {
+          headersObj[key] = value;
+        });
+        return {
+          getHeaders: () => headersObj,
+          getAsJson: () => getText().then((text) => {
+            try {
+              return JSON.parse(text);
+            } catch (e) {
+              throw new Error("Invalid JSON response");
+            }
+          }),
+          getContent: () => getText(),
+          getContentText: () => getText(),
+          getBlob: () => getBlob(),
+          getResponseCode: () => response.status
+        };
+      }
+    };
     var FormatUtils = {
       /**
        * Universal ID parser: parses comma/semicolon separated string to array of numeric IDs
@@ -1460,6 +1235,102 @@ var require_index = __commonJS({
         }, {});
       }
     };
+    var FileUtils = class FileUtils {
+      /**
+       * Parse CSV string into array of arrays
+       *
+       * @param {string} csvString - The CSV string to parse
+       * @param {string} [delimiter=','] - The delimiter to use for parsing CSV
+       * @returns {Array<Array<string>>} Parsed CSV data
+       */
+      static parseCsv(csvString, delimiter = ",") {
+        return csvString.split("\n").filter((line) => line.trim() !== "").map((line) => line.split(delimiter).map((cell) => {
+          const trimmed = cell.trim();
+          if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+            return trimmed.slice(1, -1).replace(/""/g, '"');
+          }
+          return trimmed;
+        }));
+      }
+      /**
+       * Unzip a blob/buffer
+       *
+       * @param {Buffer} data - The data to unzip
+       * @returns {Array<{getDataAsString: Function}>} Array of file-like objects with getDataAsString method
+       */
+      static unzip(data) {
+        const zip = new AdmZip(data);
+        return zip.getEntries().map((entry) => ({
+          getDataAsString: () => entry.getData().toString("utf8")
+        }));
+      }
+    };
+    var DateUtils = class DateUtils {
+      /**
+       * Format the given date to ISO format (YYYY-MM-DD).
+       *
+       * @param {Date} date - The date to format.
+       * @returns {string} ISO formatted date (YYYY-MM-DD)
+       */
+      static formatDate(date) {
+        return date.toISOString().split("T")[0];
+      }
+    };
+    var CryptoUtils = class CryptoUtils {
+      /**
+       * Mac algorithm constants.
+       *
+       * @type {Object}
+       */
+      static get MacAlgorithm() {
+        return {
+          HMAC_SHA_256: "HMAC_SHA_256",
+          HMAC_SHA_384: "HMAC_SHA_384",
+          HMAC_SHA_512: "HMAC_SHA_512",
+          HMAC_SHA_1: "HMAC_SHA_1",
+          HMAC_MD5: "HMAC_MD5"
+        };
+      }
+      /**
+       * Get a UUID. Format: `${string}-${string}-${string}-${string}-${string}`
+       *
+       * @returns {string} UUID
+       */
+      static getUuid() {
+        const crypto = require("node:crypto");
+        return crypto.randomUUID();
+      }
+      /**
+       * Encode the given data to base64.
+       *
+       * @param {string} data - The data to encode.
+       * @returns {string}
+       */
+      static base64Encode(data) {
+        return Buffer.from(data).toString("base64");
+      }
+      /**
+       * Compute the HMAC signature for the given data.
+       *
+       * @param {string} algorithm - The algorithm to use (e.g., 'HMAC_SHA_256', 'sha256').
+       * @param {string} data - The data to compute the signature for.
+       * @param {string} key - The key to use.
+       * @returns {Array<number>} Byte array of the signature
+       */
+      static computeHmacSignature(algorithm, data, key) {
+        const crypto = require("node:crypto");
+        const algorithmMap = {
+          "HMAC_SHA_256": "sha256",
+          "HMAC_SHA_384": "sha384",
+          "HMAC_SHA_512": "sha512",
+          "HMAC_SHA_1": "sha1",
+          "HMAC_MD5": "md5"
+        };
+        const nodeAlgorithm = algorithmMap[algorithm] || algorithm.toLowerCase().replace("hmac_", "");
+        const buffer = crypto.createHmac(nodeAlgorithm, key).update(data).digest();
+        return Array.from(buffer);
+      }
+    };
     var ConnectorUtils = {
       /**
        * Check if a node is a time series node
@@ -1482,6 +1353,17 @@ var require_index = __commonJS({
         }, {});
       }
     };
+    var AsyncUtils = class AsyncUtils {
+      /**
+       * Async delay for the given number of milliseconds.
+       *
+       * @param {number} ms - The number of milliseconds to delay.
+       * @returns {Promise<void>}
+       */
+      static async delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+      }
+    };
     class RunConfigDto {
       constructor(config) {
         this._config = config;
@@ -1893,902 +1775,38 @@ var require_index = __commonJS({
         );
       }
     }
-    var GoogleSheetsConfig = class GoogleSheetsConfig extends AbstractConfig {
-      //---- constructor -------------------------------------------------
-      constructor(configRange) {
-        if (typeof configRange.getA1Notation !== "function") {
-          throw new Error(`Unable to create an GoogleSheetsConfig object. The first constructor's parameter must be an SpreadsheetApp.Sheet object`);
-        }
-        let configObject = {};
-        configRange.getValues().forEach((row, index) => {
-          var name = row[0].replaceAll(/[^a-zA-Z0-9]/gi, "");
-          if (!["", "Parameters", "Status", "Name"].includes(name)) {
-            var value = row[1];
-            configObject[name] = {};
-            if (value || value === 0) {
-              configObject[name].value = value;
-            }
-            if (row[0].slice(-1) == "*") {
-              configObject[name].isRequired = true;
-            }
-            if (["Log", "CurrentStatus", "LastImportDate", "LastRequestedDate", "DestinationSpreadsheet"].includes(name)) {
-              configObject[name].cell = configRange.offset(index, 1, 1, 1);
-            }
-          }
-        });
-        configObject.configSpreadsheet = configRange.getSheet().getParent();
-        configObject.Log.timeZone = configRange.getSheet().getParent().getSpreadsheetTimeZone();
-        super(configObject);
-        this.mergeParameters({
-          MaxRunTimeout: {
-            isRequired: true,
-            requiredType: "number",
-            default: 30
-          },
-          NotifyByEmail: {
-            isRequired: false,
-            requiredType: "string",
-            default: ""
-          },
-          NotifyByGoogleChat: {
-            isRequired: false,
-            requiredType: "string",
-            default: ""
-          },
-          NotifyWhen: {
-            isRequired: false,
-            requiredType: "string",
-            default: "Never"
-          }
-        });
-      }
-      //---- handleStatusUpdate -----------------------------------------------
-      /**
-       * @param {Object} params - Parameters object with status and other properties
-       * @param {number} params.status - Status constant
-       * @param {string} params.error - Error message for Error status
-       */
-      handleStatusUpdate({ status, error }) {
-        this.manageTimeoutTrigger(status);
-        this.updateCurrentStatus(status);
-        if (this.shouldSendNotifications(status)) {
-          this.sendNotifications({ status, error });
-        }
-      }
-      //----------------------------------------------------------------
-      //---- manageTimeoutTrigger ----------------------------------------
-      /**
-       * Manage timeout trigger based on current status
-       * @param {number} status - Status constant
-       */
-      manageTimeoutTrigger(status) {
-        if (status === EXECUTION_STATUS.IMPORT_IN_PROGRESS) {
-          this.createTimeoutTrigger();
-        } else if (status === EXECUTION_STATUS.IMPORT_DONE || status === EXECUTION_STATUS.ERROR) {
-          this.removeTimeoutTrigger();
-        }
-      }
-      //---- getStatusProperties ------------------------------------------
-      /**
-       * Get all properties for a given status
-       * @param {number} status - Status constant
-       * @returns {Object} - Object with all status properties
-       */
-      getStatusProperties(status) {
-        switch (status) {
-          case EXECUTION_STATUS.IMPORT_IN_PROGRESS:
-            return {
-              displayText: "Import in progress",
-              backgroundColor: "#c9e3f9",
-              notificationMessage: "Import is in progress."
-            };
-          case EXECUTION_STATUS.CLEANUP_IN_PROGRESS:
-            return {
-              displayText: "CleanUp in progress",
-              backgroundColor: "#c9e3f9",
-              notificationMessage: "Cleanup is in progress."
-            };
-          case EXECUTION_STATUS.IMPORT_DONE:
-            return {
-              displayText: "Done",
-              backgroundColor: "#d4efd5",
-              notificationMessage: "Import completed successfully."
-            };
-          case EXECUTION_STATUS.CLEANUP_DONE:
-            return {
-              displayText: "Done",
-              backgroundColor: "#d4efd5",
-              notificationMessage: "Cleanup completed successfully."
-            };
-          case EXECUTION_STATUS.ERROR:
-            return {
-              displayText: "Error",
-              backgroundColor: "#fdd2cf",
-              notificationMessage: "Error occurred"
-            };
-          default:
-            throw new Error(`Unknown status constant: ${status}`);
-        }
-      }
-      //----------------------------------------------------------------
-      //---- updateCurrentStatus -----------------------------------------
-      /**
-       * @param {number} status - Status constant
-       */
-      updateCurrentStatus(status) {
-        const statusProps = this.getStatusProperties(status);
-        this.CurrentStatus.cell.setValue(statusProps.displayText);
-        this.CurrentStatus.cell.setBackground(statusProps.backgroundColor);
-      }
-      //----------------------------------------------------------------
-      //---- updateLastImportDate ----------------------------------------
-      /**
-       * updating the last import attempt date in a config sheet
-       */
-      updateLastImportDate() {
-        this.LastImportDate.cell.setValue(
-          EnvironmentAdapter.formatDate(/* @__PURE__ */ new Date(), this.Log.timeZone, "yyyy-MM-dd HH:mm:ss")
-        );
-      }
-      //----------------------------------------------------------------
-      //---- updateLastRequstedDate --------------------------------------
-      /**
-       * Updating the last requested date in a config sheet
-       * @param date Date requested date
-       */
-      updateLastRequstedDate(date) {
-        if ("LastRequestedDate" in this && (!this.LastRequestedDate.value || date.getTime() != this.LastRequestedDate.value.getTime())) {
-          this.LastRequestedDate.value = new Date(date.getTime());
-          this.LastRequestedDate.cell.setValue(EnvironmentAdapter.formatDate(date, this.Log.timeZone, "yyyy-MM-dd HH:mm:ss"));
-        }
-      }
-      //----------------------------------------------------------------
-      //---- updateFieldsSheet -------------------------------------------
-      /**
-       * Updating the content of the fields list to simplify the selection of fields for import
-       * @param connector AbstractSource
-       * @param sheetName string, Fields by default
-       */
-      updateFieldsSheet(source, sheetName = "Fields") {
-        this.validate();
-        var configSheetStorage = new GoogleSheetsStorage(
-          this.mergeParameters({
-            DestinationSheetName: {
-              // @TODO: make sure it would affect destination sheet for import data. CONFIG is an object. Probably we might dublicate it
-              value: sheetName
-            }
-          }),
-          ["id"]
-        );
-        var groups = source.getFieldsSchema();
-        var data = [];
-        for (var groupName in groups) {
-          data.push({
-            "id": groupName,
-            "✔️": groupName,
-            "name": "",
-            "description": `=IF( COUNTIFS(A:A, "${groupName} *", B:B, TRUE) > 0, COUNTIFS(A:A, "${groupName} *", B:B, TRUE), "")`
-          });
-          data.push({ "id": `${groupName} !desc`, "✔️": groups[groupName].description });
-          data.push({ "id": `${groupName} !doc`, "✔️": groups[groupName].documentation });
-          if (groups[groupName].fields) {
-            for (var fieldName in groups[groupName].fields) {
-              data.push({
-                "id": groupName + " " + fieldName,
-                "name": fieldName,
-                "description": groups[groupName].fields[fieldName].description
-              });
-            }
-            data.push({ "id": `${groupName} zzz_separator` });
-          }
-        }
-        for (var groupName in groups) {
-          var groupRow = configSheetStorage.getRecordByRecordFields({ "id": groupName });
-          if (groupRow !== null) {
-            let depth = configSheetStorage.SHEET.getRowGroupDepth(groupRow.rowIndex + 5);
-            if (depth > 0) {
-              configSheetStorage.SHEET.getRowGroup(groupRow.rowIndex + 5, depth).remove();
-            }
-          }
-        }
-        configSheetStorage.saveData(data);
-        configSheetStorage.SHEET.sort(configSheetStorage.getColumnIndexByName("id"));
-        configSheetStorage.loadDataFromSheet();
-        configSheetStorage.SHEET.hideColumns(configSheetStorage.getColumnIndexByName("id"));
-        configSheetStorage.SHEET.setColumnWidth(configSheetStorage.getColumnIndexByName("✔️"), 25);
-        configSheetStorage.SHEET.autoResizeColumn(3);
-        var checkboxRule = SpreadsheetApp.newDataValidation().requireCheckbox().build();
-        for (var groupName in groups) {
-          var groupRow = configSheetStorage.getRecordByRecordFields({ "id": groupName });
-          var range = configSheetStorage.SHEET.getRange(`${groupRow.rowIndex + 2}:${groupRow.rowIndex + 2}`);
-          range.setFontWeight("bold").setBackground("black").setFontColor("white");
-          var groupRow = configSheetStorage.getRecordByRecordFields({ "id": `${groupName} !desc` });
-          var range = configSheetStorage.SHEET.getRange(`${groupRow.rowIndex + 2}:${groupRow.rowIndex + 3}`);
-          range.setBackground("#f3f3f3");
-          var checkboxesColumnIndex = configSheetStorage.getColumnIndexByName("✔️");
-          var groupNameRow = configSheetStorage.getRecordByRecordFields({ "id": groupName });
-          var groupFieldsCount = this.getFieldsCountByGroupName(configSheetStorage, groupName);
-          configSheetStorage.SHEET.getRange(groupNameRow.rowIndex + 5, checkboxesColumnIndex, groupFieldsCount).setDataValidation(checkboxRule);
-          configSheetStorage.SHEET.getRange(`${groupNameRow.rowIndex + 5}:${groupNameRow.rowIndex + 4 + groupFieldsCount}`).shiftRowGroupDepth(1);
-        }
-        configSheetStorage.SHEET.collapseAllRowGroups();
-      }
-      //----------------------------------------------------------------
-      //---- getFieldsCountByGroupName -----------------------------------
-      /**
-       * @param GoogleSheetsConfig object
-       * @param groupName string name of the group
-       * @return integer number of fields of requested group
-       */
-      getFieldsCountByGroupName(configSheetStorage, groupName) {
-        return Object.values(configSheetStorage.values).filter((element) => element.name && element.id.startsWith(`${groupName} `)).length;
-      }
-      //----------------------------------------------------------------
-      //---- isInProgress ------------------------------------------------
-      /**
-       * Checking current status if it is in progress or not
-       * @return boolean true is process in progress
-       */
-      isInProgress() {
-        let isInProgress = null;
-        if (this.CurrentStatus.cell.getValue().indexOf("progress") !== -1) {
-          let diff = (/* @__PURE__ */ new Date() - new Date(EnvironmentAdapter.formatDate(this.LastImportDate.cell.getValue(), this.Log.timeZone, "yyyy-MM-dd HH:mm:ss"))) / (1e3 * 60);
-          isInProgress = diff < this.MaxRunTimeout.value;
-        } else {
-          isInProgress = false;
-        }
-        return isInProgress;
-      }
-      //----------------------------------------------------------------
-      //---- addWarningToCurrentStatus -----------------------------------
-      addWarningToCurrentStatus() {
-        this.CurrentStatus.cell.setBackground("#fff0c4");
-      }
-      //----------------------------------------------------------------
-      //---- validate ----------------------------------------------------
-      /**
-       * validating if google sheets config is correct
-       */
-      validate() {
-        let scriptTimeZone = Session.getScriptTimeZone();
-        if (scriptTimeZone != "Etc/UTC") {
-          throw new Error(`The Apps Script time zone must be set to UTC to avoid confusion with dates. Currently, it is set to ${scriptTimeZone} instead. Update the time zone in Project Settings`);
-        }
-        super.validate();
-      }
-      //----------------------------------------------------------------
-      //---- logMessage --------------------------------------------------
-      /**
-       * @param string message to Log
-       */
-      logMessage(message, removeExistingMessage = false) {
-        console.log(message);
-        let formattedDate = EnvironmentAdapter.formatDate(/* @__PURE__ */ new Date(), this.Log.timeZone, "yyyy-MM-dd HH:mm:ss");
-        let currentLog = removeExistingMessage ? "" : this.Log.cell.getValue();
-        currentLog ? currentLog += "\n" : "";
-        let emoji = "☑️ ";
-        let match;
-        if (match = message.match(new RegExp("^(\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F|\\p{Extended_Pictographic})\\s+", "u"))) {
-          emoji = match[0];
-          message = message.slice(2).trim();
-        }
-        this.Log.cell.setValue(
-          `${currentLog}${emoji}${formattedDate}: ${message}`
-        );
-        this.updateLastImportDate();
-      }
-      showCredentialsDialog(source) {
-        const ui = SpreadsheetApp.getUi();
-        const template = HtmlService.createTemplateFromFile("Views/credentials-input-dialog");
-        template.source = source;
-        const html = template.evaluate().setWidth(400).setHeight(450);
-        ui.showModalDialog(html, `${source.constructor.name} Credentials`);
-      }
-      showManualBackfillDialog(source) {
-        const ui = SpreadsheetApp.getUi();
-        const template = HtmlService.createTemplateFromFile("Views/manual-backfill-dialog");
-        template.source = source;
-        const html = template.evaluate().setWidth(600).setHeight(300);
-        ui.showModalDialog(html, "Manual Backfill");
-      }
-      //---- sendNotifications -------------------------------------------
-      /**
-       * Send notifications based on configuration settings
-       * @param {Object} params - Parameters object
-       * @param {string} params.status - Current status value
-       * @param {string} params.error - Error message for Error status
-       */
-      sendNotifications({ status, error }) {
-        try {
-          const { title, messageWithDetails } = this.prepareNotificationContent({ status, error });
-          if (this.NotifyByEmail && this.NotifyByEmail.value && this.NotifyByEmail.value.trim()) {
-            EmailNotification.send({
-              to: this.NotifyByEmail.value,
-              subject: title,
-              message: messageWithDetails
-            });
-          }
-          if (this.NotifyByGoogleChat && this.NotifyByGoogleChat.value && this.NotifyByGoogleChat.value.trim()) {
-            GoogleChatNotification.send({
-              webhookUrl: this.NotifyByGoogleChat.value.trim(),
-              message: messageWithDetails
-            });
-          }
-        } catch (error2) {
-          this.logMessage(`⚠️ Notification error: ${error2.message}`);
-        }
-      }
-      //----------------------------------------------------------------
-      //---- prepareNotificationContent ----------------------------------
-      /**
-       * Prepare notification title and message content
-       * @param {Object} params - Parameters object
-       * @param {number} params.status - Status constant
-       * @param {string} params.error - Error message for Error status
-       * @returns {Object} - Object with title and messageWithDetails properties
-       */
-      prepareNotificationContent({ status, error }) {
-        const documentName = this.configSpreadsheet.getName();
-        const documentUrl = this.configSpreadsheet.getUrl();
-        const { displayText, notificationMessage } = this.getStatusProperties(status);
-        const title = `${documentName} - Status: ${displayText}`;
-        return {
-          title,
-          messageWithDetails: `${title}
-${documentUrl}
-
-${notificationMessage}${status === EXECUTION_STATUS.ERROR && error ? `: ${error}` : ""}`
-        };
-      }
-      //----------------------------------------------------------------
-      //---- shouldSendNotifications -------------------------------------
-      /**
-       * Determine if notifications should be sent based on status and filter setting
-       * @param {number} status - Status constant
-       * @returns {boolean} - True if notifications should be sent
-       */
-      shouldSendNotifications(status) {
-        var _a;
-        const notifyWhen = (_a = this.NotifyWhen) == null ? void 0 : _a.value;
-        switch (notifyWhen) {
-          case "On error":
-            return status === EXECUTION_STATUS.ERROR;
-          case "On success":
-            return status === EXECUTION_STATUS.IMPORT_DONE;
-          case "Always":
-            return status === EXECUTION_STATUS.ERROR || status === EXECUTION_STATUS.IMPORT_DONE;
-          case "Never":
-          case "":
-          default:
-            return false;
-        }
-      }
-      //----------------------------------------------------------------
-      //---- createTimeoutTrigger ----------------------------------------
-      createTimeoutTrigger() {
-        this.removeTimeoutTrigger();
-        ScriptApp.newTrigger("checkForTimeout").timeBased().after((this.MaxRunTimeout.value * 2 + 1) * 60 * 1e3).create();
-      }
-      //----------------------------------------------------------------
-      //---- removeTimeoutTrigger ----------------------------------------
-      removeTimeoutTrigger() {
-        const triggers = ScriptApp.getProjectTriggers();
-        let removedCount = 0;
-        triggers.forEach((trigger) => {
-          if (trigger.getHandlerFunction() === "checkForTimeout") {
-            ScriptApp.deleteTrigger(trigger);
-            removedCount++;
-          }
-        });
-        console.log(`[TimeoutTrigger] ${removedCount > 0 ? `Removed ${removedCount} timeout trigger(s)` : "No timeout triggers found to remove"}`);
-      }
-      //----------------------------------------------------------------
-      //---- checkForTimeout ---------------------------------------------
-      checkForTimeout() {
-        if (!this.isInProgress()) {
-          console.log("[TimeoutTrigger] Status is NOT in progress, setting to Error and sending notification");
-          this.handleStatusUpdate({
-            status: EXECUTION_STATUS.ERROR,
-            error: "Import was interrupted (likely due to timeout)"
-          });
-        } else {
-          console.log("[TimeoutTrigger] Status is still in progress");
-        }
-      }
-      //----------------------------------------------------------------
-    };
-    var GoogleChatNotification = class GoogleChatNotification {
-      /**
-       * Send Google Chat notification
-       * @param {Object} params - Parameters object
-       * @param {string} params.webhookUrl - Google Chat webhook URL
-       * @param {string} params.message - Formatted notification message
-       */
-      static send(params) {
-        const { webhookUrl, message } = params;
-        if (!webhookUrl || !webhookUrl.trim()) {
-          return;
-        }
-        try {
-          const response = EnvironmentAdapter.fetch(webhookUrl.trim(), {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json; charset=UTF-8"
-            },
-            payload: JSON.stringify({ text: message })
-          });
-          if (response.getResponseCode() === 200) {
-            console.log("Google Chat notification sent successfully");
-          } else {
-            console.error(`Google Chat notification failed with status: ${response.getResponseCode()}`);
-          }
-        } catch (error) {
-          console.error("Failed to send Google Chat notification:", error);
-        }
-      }
-    };
-    var EmailNotification = class EmailNotification {
-      /**
-       * Send email notification
-       * @param {Object} params - Parameters object
-       * @param {string} params.to - Email address(es) to send to (can be multiple separated by commas)
-       * @param {string} params.subject - Email subject line
-       * @param {string} params.message - Formatted notification message
-       */
-      static send(params) {
-        const { to, subject, message } = params;
-        if (!to || !to.trim()) {
-          return;
-        }
-        try {
-          const emailAddresses = to.split(",").map((email) => email.trim()).filter((email) => email.length > 0).filter((email) => this.isValidEmail(email)).join(",");
-          if (!emailAddresses) {
-            console.log("Email notification skipped: no valid email addresses found");
-            return;
-          }
-          MailApp.sendEmail(
-            emailAddresses,
-            subject,
-            message,
-            { noReply: true }
-          );
-          console.log(`Email notification sent successfully to: ${emailAddresses}`);
-        } catch (error) {
-          console.error(`Failed to send email notification: ${error.message}`);
-        }
-      }
-      /**
-       * Validate email address format
-       * @param {string} email - Email address to validate
-       * @returns {boolean} - True if email is valid
-       */
-      static isValidEmail(email) {
-        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-        const isValid = emailRegex.test(email);
-        if (!isValid) {
-          console.log(`Invalid email address skipped: ${email}`);
-        }
-        return isValid;
-      }
-    };
     const Core = {
       AbstractException,
       HttpRequestException,
       UnsupportedEnvironmentException,
-      EnvironmentAdapter,
       AbstractStorage,
       AbstractSource,
       AbstractRunConfig,
       AbstractConnector,
       AbstractConfig,
+      HttpUtils,
+      FileUtils,
+      DateUtils,
+      CryptoUtils,
+      AsyncUtils,
       RunConfigDto,
       SourceConfigDto,
       StorageConfigDto,
       ConfigDto,
       NodeJsConfig,
-      GoogleSheetsConfig,
-      GoogleChatNotification,
-      EmailNotification,
       HTTP_STATUS,
-      ENVIRONMENT,
       EXECUTION_STATUS,
       RUN_CONFIG_TYPE,
       CONFIG_ATTRIBUTES
     };
-    const GoogleSheets = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
-      var GoogleSheetsStorage2 = class GoogleSheetsStorage extends AbstractStorage2 {
-        //---- constructor -------------------------------------------------
-        /**
-         * Asbstract class making Google Sheets data active in Apps Script to simplity read/write operations
-         * @param config (object) instance of AbscractConfig
-         * @param uniqueKeyColumns (mixed) a name of column with unique key or array with columns names
-         * @param schema (object) object with structure like {fieldName: {type: "number", description: "smth" } }
-         */
-        constructor(config, uniqueKeyColumns, schema = null) {
-          super(
-            config.mergeParameters({
-              CleanUpToKeepWindow: {
-                requiredType: "number"
-              },
-              DestinationSheetName: {
-                isRequired: true,
-                default: "Data"
-              }
-            }),
-            uniqueKeyColumns,
-            schema
-          );
-          this.SHEET = this.getDestinationSheet(config);
-          this.loadDataFromSheet();
-        }
-        //----------------------------------------------------------------
-        //---- loadDataFromSheet -------------------------------------------
-        /**
-         * reading Data from the source sheet and loading it to this.values
-         */
-        loadDataFromSheet() {
-          const values = this.SHEET.getDataRange().getValues();
-          this.columnNames = values.shift();
-          if (this.uniqueKeyColumns.some((column) => !this.columnNames.includes(column))) {
-            throw new Error(`Sheet '${this.SHEET.getName()}' is missing one the folling columns required for unique key: column '${this.uniqueKeyColumns}'`);
-          }
-          this.values = values.reduce((acc, row, rowIndex) => {
-            const uniqueKey = this.uniqueKeyColumns.reduce((accumulator, columnName) => {
-              let index = this.columnNames.indexOf(columnName);
-              accumulator += `|${row[index]}`;
-              return accumulator;
-            }, []);
-            acc[uniqueKey] = {
-              ...this.columnNames.reduce((obj, col, colIndex) => ({
-                ...obj,
-                [col]: row[colIndex]
-              }), {}),
-              rowIndex
-              // Add row index for reference
-            };
-            return acc;
-          }, {});
-          this.addedRecordsBuffer = [];
-        }
-        //----------------------------------------------------------------
-        //---- getDestinationSheet -----------------------------------------
-        /**
-         * @param object destination Spreadsheet Config
-         * @param object destination Sheet Name Config
-         * @return Sheet object for data Destination
-         */
-        getDestinationSheet(config) {
-          if (!this.SHEET) {
-            if (!config.DestinationSpreadsheet || !config.DestinationSpreadsheet.value) {
-              config.DestinationSpreadsheet = { "spreadsheet": config.configSpreadsheet };
-            } else {
-              let match = config.DestinationSpreadsheet.value.match(/\/d\/([a-zA-Z0-9-_]+)/);
-              if (match && match[1]) {
-                config.DestinationSpreadsheet.spreadsheet = SpreadsheetApp.openById(match[1]);
-              } else {
-                let match2 = config.DestinationSpreadsheet.cell.getRichTextValue().getLinkUrl().match(/\/d\/([a-zA-Z0-9-_]+)/);
-                if (match2 && match2[1]) {
-                  config.DestinationSpreadsheet.spreadsheet = SpreadsheetApp.openById(match2[1]);
-                } else {
-                  throw new Error(`Destination Spreadsheet must be specified in config either by Spreadsheet Id or by a link to spreadsheet`);
-                }
-              }
-            }
-            if (config.DestinationSpreadsheet.spreadsheet == null) {
-              this.config.logMessage(`Cannot load destination sheet document`);
-            }
-            config.DestinationSpreadsheet.sheet = config.DestinationSpreadsheet.spreadsheet.getSheetByName(
-              config.DestinationSheetName.value
-            );
-            if (!config.DestinationSpreadsheet.sheet) {
-              config.DestinationSpreadsheet.sheet = config.DestinationSpreadsheet.spreadsheet.insertSheet(
-                config.DestinationSheetName.value,
-                config.DestinationSpreadsheet.spreadsheet.getSheets().length
-              );
-              this.config.logMessage(`Sheet '${config.DestinationSheetName.value}' was created.`);
-            }
-            this.SHEET = config.DestinationSpreadsheet.sheet;
-            if (this.isEmpty()) {
-              this.addHeader(this.uniqueKeyColumns);
-              this.config.logMessage(`Columns for unique keys were added to '${config.DestinationSheetName.value}' sheet.`);
-            }
-          }
-          return this.SHEET;
-        }
-        //----------------------------------------------------------------
-        //---- addRecord ---------------------------------------------------
-        /**
-         * Checking if record exists by id
-         * @param object {record} object with record data
-         * @param Boolean {useBuffer}: Set to `false` if the record must be saved instantly, or `true` to save it later using `this.saveAddedRecordsFromBuffer()`.
-         * @return object {record} with added rowIndex property
-         */
-        addRecord(record, useBuffer = false) {
-          record = this.stringifyNeastedFields(record);
-          let uniqueKey = this.getUniqueKeyByRecordFields(record);
-          if (useBuffer) {
-            this.addedRecordsBuffer[uniqueKey] = record;
-          } else {
-            let data = this.columnNames.map((key) => record[key] || "");
-            this.SHEET.appendRow(data);
-            record.rowIndex = this.SHEET.getLastRow() - 2;
-            this.values[uniqueKey] = record;
-          }
-          return record;
-        }
-        //----------------------------------------------------------------
-        //---- saveData ----------------------------------------------------
-        /**
-         * Saving data to a storage
-         * @param {data} array of assoc objects with records to save
-         */
-        saveData(data) {
-          var recordsAdded = 0;
-          var recordsUpdated = 0;
-          data.map((row) => {
-            let newFields = Object.keys(row).filter((column2) => !this.columnNames.includes(column2));
-            for (var column in newFields) {
-              this.addColumn(newFields[column], this.columnNames.length + 1);
-              this.config.logMessage(`Column '${newFields[column]}' was added to '${this.SHEET.getName()}' sheet`);
-            }
-            if (this.isRecordExists(row)) {
-              if (this.updateRecord(row)) {
-                recordsUpdated++;
-              }
-            } else {
-              this.addRecord(row, true);
-              recordsAdded += this.saveRecordsAddedToBuffer(100);
-            }
-          });
-          recordsAdded += this.saveRecordsAddedToBuffer(0);
-          if (recordsAdded > 0) {
-            this.config.logMessage(`${recordsAdded} records were added`);
-          }
-          if (recordsUpdated > 0) {
-            this.config.logMessage(`${recordsUpdated} records were updated`);
-          }
-        }
-        //----------------------------------------------------------------
-        //---- saveRecordsAddedToBuffer ------------------------------------
-        /**
-         * Add records from buffer to a sheet
-         * @param (integer) {maxBufferSize} record will be added only if buffer size if larger than this parameter
-         */
-        saveRecordsAddedToBuffer(maxBufferSize = 0) {
-          let recordsAdded = 0;
-          let bufferSize = Object.keys(this.addedRecordsBuffer).length;
-          if (bufferSize && bufferSize >= maxBufferSize) {
-            let startIndex = this.SHEET.getLastRow() - 2;
-            let index = 1;
-            let data = [];
-            for (var uniqueKey in this.addedRecordsBuffer) {
-              let record = this.addedRecordsBuffer[uniqueKey];
-              record.rowIndex = startIndex + index++;
-              this.values[uniqueKey] = record;
-              data.push(this.columnNames.map((key) => record[key] || ""));
-            }
-            this.SHEET.getRange(startIndex + 3, 1, data.length, data[0].length).setValues(data);
-            recordsAdded = bufferSize;
-            this.addedRecordsBuffer = {};
-          }
-          return recordsAdded;
-        }
-        //----------------------------------------------------------------
-        //---- updateRecord ------------------------------------------------
-        /**
-         * Update content of an existing record
-         * @param object {record} object with record data
-         * @return boolean Returns true if the record was updated; otherwise, returns false
-         */
-        updateRecord(record) {
-          record = this.stringifyNeastedFields(record);
-          let uniqueKey = this.getUniqueKeyByRecordFields(record);
-          var existingRecord = this.getRecordByUniqueKey(uniqueKey);
-          var isRecordUpdated = false;
-          this.columnNames.forEach((columnName, columnIndex) => {
-            if (columnName in record && !this.areValuesEqual(record[columnName], existingRecord[columnName])) {
-              console.log(`${uniqueKey}: ${existingRecord[columnName]} ${typeof existingRecord[columnName]} → ${record[columnName]} ${typeof record[columnName]}`);
-              this.SHEET.getRange(existingRecord.rowIndex + 2, columnIndex + 1, 1, 1).setValue(record[columnName]);
-              existingRecord[columnName] = record[columnName];
-              isRecordUpdated = true;
-            }
-          });
-          return isRecordUpdated;
-        }
-        //----------------------------------------------------------------
-        //---- deleteRecord ------------------------------------------------
-        /**
-         * Delete record from a sheet
-         * @param uniqueKey {string} unique key of the record to delete
-         */
-        deleteRecord(uniqueKey) {
-          if (!(uniqueKey in this.values)) {
-            throw new Error(`Unable to delete the record with ID ${uniqueKey} because it was not found`);
-          } else if (!("rowIndex" in this.values[uniqueKey])) {
-            throw new Error(`Unable to delete the record with ID ${uniqueKey} because it does not have a rowIndex`);
-          } else {
-            let rowIndex = this.values[uniqueKey].rowIndex;
-            this.SHEET.deleteRow(rowIndex + 2);
-            for (uniqueKey in this.values) {
-              if (this.values[uniqueKey].rowIndex > rowIndex) {
-                this.values[uniqueKey].rowIndex--;
-              }
-            }
-          }
-        }
-        //----------------------------------------------------------------
-        //---- addHeader ---------------------------------------------------
-        /**
-         * Adding header to sheet
-         * @param target Sheet
-         * @param array column names to be added
-         */
-        addHeader(columnNames) {
-          columnNames.forEach((columnName, index) => {
-            this.addColumn(columnName, index + 1);
-          });
-          this.SHEET.getRange("1:1").setBackground("#f3f3f3").setHorizontalAlignment("center");
-          this.SHEET.setFrozenRows(1);
-        }
-        //----------------------------------------------------------------
-        //---- addColumn ---------------------------------------------------
-        /**
-         * Adding a column to the sheet
-         * @param columnName (string) column name
-         * @param columnIndex (integer) optional; column index
-         */
-        addColumn(columnName, columnIndex = 1) {
-          const numColumns = this.SHEET.getMaxColumns();
-          if (columnIndex <= 0 || columnIndex > numColumns + 1) {
-            throw new Error(`Column index ${columnIndex} is out of bounds (1-${numColumns + 1})`);
-          }
-          if (columnIndex <= numColumns) {
-            const headerValue = this.SHEET.getRange(1, columnIndex).getValue();
-            if (headerValue !== "") {
-              const findFirstEmptyColumn = (startIndex) => {
-                let index = startIndex;
-                let foundEmpty = false;
-                while (index <= numColumns) {
-                  if (this.SHEET.getRange(1, index).getValue() === "") {
-                    foundEmpty = true;
-                    break;
-                  }
-                  index++;
-                }
-                return {
-                  columnIndex: index,
-                  foundEmpty
-                };
-              };
-              const result = findFirstEmptyColumn(columnIndex);
-              if (!result.foundEmpty) {
-                this.SHEET.insertColumnAfter(numColumns);
-                columnIndex = numColumns + 1;
-              } else {
-                this.SHEET.insertColumnBefore(result.columnIndex);
-                columnIndex = result.columnIndex;
-              }
-            }
-          } else {
-            this.SHEET.insertColumnAfter(numColumns);
-            columnIndex = numColumns + 1;
-          }
-          this.SHEET.getRange(1, columnIndex).setValue(columnName);
-          if (this.schema != null && columnName in this.schema && "GoogleSheetsFormat" in this.schema[columnName]) {
-            let columnLetter = String.fromCharCode(64 + columnIndex);
-            console.log(
-              columnName,
-              this.schema[columnName]["GoogleSheetsFormat"],
-              this.SHEET.getRange(`${columnLetter}:${columnLetter}`).getA1Notation()
-            );
-            this.SHEET.getRange(`${columnLetter}:${columnLetter}`).setNumberFormat(this.schema[columnName]["GoogleSheetsFormat"]);
-          }
-          this.columnNames.push(columnName);
-        }
-        //----------------------------------------------------------------
-        //---- formatColumn ------------------------------------------------
-        /**
-         * Format column as it described in schema 
-         * @param columnName (string) column name
-         */
-        formatColumn(columnName) {
-          if ("type" in this.schema[columnName]) ;
-        }
-        //----------------------------------------------------------------
-        //---- getColumnIndexByName ----------------------------------------
-        /**
-         * @param columnName string column name
-         * @return integer columnIndex
-         */
-        getColumnIndexByName(columnName) {
-          const columnIndex = this.columnNames.indexOf(columnName);
-          if (columnIndex == -1) {
-            throw new Error(`Column ${columnName} not found in '${this.SHEET.getName()}' sheet`);
-          }
-          return columnIndex + 1;
-        }
-        //----------------------------------------------------------------  
-        //---- isEmpty -----------------------------------------------------
-        /**
-         * @return boolean true if sheet is empty, false overwise 
-         */
-        isEmpty() {
-          return this.SHEET.getLastRow() === 0 && this.SHEET.getLastColumn() === 0;
-        }
-        //----------------------------------------------------------------
-        //---- areValuesEqual ----------------------------------------------
-        /**
-         * Comparing to vaariables if they are equal or not
-         * @param value1 (mixed)
-         * @param value2 (mixed)
-         * @return boolean true if equal, falst overwise 
-         */
-        areValuesEqual(value1, value2) {
-          var equal = null;
-          if (typeof value1 !== "undefined" && typeof value2 !== "undefined" && ((value1 == null ? void 0 : value1.constructor.name) == "Date" || (value2 == null ? void 0 : value2.constructor.name) == "Date")) {
-            const normalizeToDate = (value) => {
-              if (value === null || value === "") return null;
-              if (value.constructor.name == "Date") return value;
-              const date = new Date(value);
-              return isNaN(date.getTime()) ? null : date;
-            };
-            const date1 = normalizeToDate(value1);
-            const date2 = normalizeToDate(value2);
-            if (date1 === null || date2 === null) {
-              return value1 === value2;
-            }
-            equal = date1.getTime() === date2.getTime();
-          } else if (typeof value1 == typeof value2) {
-            equal = value1 === value2;
-          } else if (value1 === void 0 && value2 === "" || value2 === void 0 && value1 === "") {
-            equal = true;
-          } else if (value1 === null && value2 === "" || value2 === null && value1 === "") {
-            equal = true;
-          }
-          return equal;
-        }
-        //----------------------------------------------------------------
-        //---- areHeadersNeeded ------------------------------------------
-        /**
-         * Checks if storage is empty and adds headers if needed
-         * if destination sheet is empty than header should be created based on unique key columns list
-         * @return {boolean} true if headers were added, false if they already existed
-         */
-        areHeadersNeeded() {
-          return this.isEmpty();
-        }
-        //----------------------------------------------------------------
-      };
-      const manifest = {
-        "name": "GoogleSheetsStorage",
-        "description": "Storage for Google Sheets",
-        "title": "Google Sheets",
-        "version": "0.0.0",
-        "author": "OWOX, Inc.",
-        "license": "MIT",
-        "environment": {
-          "node": {
-            "enabled": false
-          },
-          "appscript": {
-            "enabled": true
-          }
-        }
-      };
-      return {
-        GoogleSheetsStorage: GoogleSheetsStorage2,
-        manifest
-      };
-    })();
     const GoogleBigQuery = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
+      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils2, FileUtils: FileUtils2, DateUtils: DateUtils2, CryptoUtils: CryptoUtils2, AsyncUtils: AsyncUtils2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
       var GoogleBigQueryStorage = class GoogleBigQueryStorage extends AbstractStorage2 {
         //---- constructor -------------------------------------------------
         /**
-         * Asbstract class making Google BigQuery updateable in Apps Script
-         * 
-         * @param config (object) instance of AbscractConfig
+         * Abstract class for Google BigQuery storage operations
+         *
+         * @param config (object) instance of AbstractConfig
          * @param uniqueKeyColumns (mixed) a name of column with unique key or array with columns names
          * @param schema (object) object with structure like {fieldName: {type: "number", description: "smth" } }
          * @param description (string) string with storage description }
@@ -2834,22 +1852,29 @@ ${notificationMessage}${status === EXECUTION_STATUS.ERROR && error ? `: ${error}
             schema,
             description
           );
-          this.checkIfGoogleBigQueryIsConnected();
-          this.loadTableSchema();
           this.updatedRecordsBuffer = {};
           this.totalRecordsProcessed = 0;
         }
+        //---- init --------------------------------------------------------
+        /**
+         * Initializing storage
+         */
+        async init() {
+          this.checkIfGoogleBigQueryIsConnected();
+          await this.loadTableSchema();
+        }
+        //----------------------------------------------------------------
         //---- loads Google BigQuery Table Schema ---------------------------
-        loadTableSchema() {
+        async loadTableSchema() {
           this.existingColumns = this.getAListOfExistingColumns() || {};
           if (Object.keys(this.existingColumns).length == 0) {
-            this.createDatasetIfItDoesntExist();
-            this.existingColumns = this.createTableIfItDoesntExist();
+            await this.createDatasetIfItDoesntExist();
+            this.existingColumns = await this.createTableIfItDoesntExist();
           } else {
             let selectedFields = this.getSelectedFields();
             let newFields = selectedFields.filter((column) => !Object.keys(this.existingColumns).includes(column));
             if (newFields.length > 0) {
-              this.addNewColumns(newFields);
+              await this.addNewColumns(newFields);
             }
           }
         }
@@ -2887,17 +1912,17 @@ ${notificationMessage}${status === EXECUTION_STATUS.ERROR && error ? `: ${error}
           return columns;
         }
         //---- createDatasetIfItDoesntExist --------------------------------
-        createDatasetIfItDoesntExist() {
+        async createDatasetIfItDoesntExist() {
           let query = `---- Create Dataset if it not exists -----
 `;
           query += `CREATE SCHEMA IF NOT EXISTS \`${this.config.DestinationProjectID.value}.${this.config.DestinationDatasetName.value}\`
         OPTIONS (
           location = '${this.config.DestinationLocation.value}'
         )`;
-          this.executeQuery(query);
+          await this.executeQuery(query);
         }
         //---- createTableIfItDoesntExist ----------------------------------
-        createTableIfItDoesntExist() {
+        async createTableIfItDoesntExist() {
           let columns = [];
           let columnPartitioned = null;
           let existingColumns = {};
@@ -2933,15 +1958,14 @@ PARTITION BY ${columnPartitioned}`;
             query += `
 OPTIONS(description="${this.description}")`;
           }
-          this.executeQuery(query);
+          await this.executeQuery(query);
           this.config.logMessage(`Table ${this.config.DestinationDatasetID.value}.${this.config.DestinationTableName.value} was created`);
           return existingColumns;
         }
         //---- checkIfGoogleBigQueryIsConnected ---------------------
         checkIfGoogleBigQueryIsConnected() {
           if (typeof BigQuery == "undefined") {
-            throw new Error(`To import data into Google BigQuery you need to add BigQuery Service first:
-          Extension / Apps Script / Editor / Services / + BigQuery API`);
+            throw new Error(`BigQuery client library is not available. Ensure @google-cloud/bigquery is installed.`);
           }
         }
         //---- addNewColumns -----------------------------------------------
@@ -2952,7 +1976,7 @@ OPTIONS(description="${this.description}")`;
          * @param {newColumns} array with a list of new columns
          * 
          */
-        addNewColumns(newColumns) {
+        async addNewColumns(newColumns) {
           let query = "";
           let columns = [];
           for (var i in newColumns) {
@@ -2974,7 +1998,7 @@ OPTIONS(description="${this.description}")`;
 
 `;
             query += columns.join(",\n");
-            this.executeQuery(query);
+            await this.executeQuery(query);
             this.config.logMessage(`Columns '${newColumns.join(",")}' were added to ${this.config.DestinationDatasetID.value} dataset`);
           }
         }
@@ -2983,17 +2007,17 @@ OPTIONS(description="${this.description}")`;
          * Saving data to a storage
          * @param {data} array of assoc objects with records to save
          */
-        saveData(data) {
-          data.map((row) => {
+        async saveData(data) {
+          for (const row of data) {
             let newFields = Object.keys(row).filter((column) => !Object.keys(this.existingColumns).includes(column));
             if (newFields.length > 0) {
               console.log(newFields);
-              this.addNewColumns(newFields);
+              await this.addNewColumns(newFields);
             }
             this.addRecordToBuffer(row);
-            this.saveRecordsAddedToBuffer(this.config.MaxBufferSize.value);
-          });
-          this.saveRecordsAddedToBuffer();
+            await this.saveRecordsAddedToBuffer(this.config.MaxBufferSize.value);
+          }
+          await this.saveRecordsAddedToBuffer();
         }
         // ------- addReordTuBuffer ---------------------
         /**
@@ -3008,24 +2032,24 @@ OPTIONS(description="${this.description}")`;
          * Add records from buffer to a sheet
          * @param (integer) {maxBufferSize} record will be added only if buffer size if larger than this parameter
          */
-        saveRecordsAddedToBuffer(maxBufferSize = 0) {
+        async saveRecordsAddedToBuffer(maxBufferSize = 0) {
           let bufferSize = Object.keys(this.updatedRecordsBuffer).length;
           if (bufferSize && bufferSize >= maxBufferSize) {
             console.log(`Starting BigQuery MERGE operation for ${bufferSize} records...`);
-            this.executeQueryWithSizeLimit();
+            await this.executeQueryWithSizeLimit();
           }
         }
         //---- executeQueryWithSizeLimit ----------------------------------
         /**
          * Executes the MERGE query with automatic size reduction if it exceeds BigQuery limits
          */
-        executeQueryWithSizeLimit() {
+        async executeQueryWithSizeLimit() {
           const bufferKeys = Object.keys(this.updatedRecordsBuffer);
           const totalRecords = bufferKeys.length;
           if (totalRecords === 0) {
             return;
           }
-          this.executeMergeQueryRecursively(bufferKeys, totalRecords);
+          await this.executeMergeQueryRecursively(bufferKeys, totalRecords);
           this.updatedRecordsBuffer = {};
         }
         //---- executeMergeQueryRecursively --------------------------------
@@ -3034,7 +2058,7 @@ OPTIONS(description="${this.description}")`;
          * @param {Array} recordKeys - Array of record keys to process
          * @param {number} batchSize - Current batch size to attempt
          */
-        executeMergeQueryRecursively(recordKeys, batchSize) {
+        async executeMergeQueryRecursively(recordKeys, batchSize) {
           if (recordKeys.length === 0) {
             return;
           }
@@ -3048,11 +2072,11 @@ OPTIONS(description="${this.description}")`;
           const maxQuerySize = 1024 * 1024;
           if (querySize > maxQuerySize) {
             console.log(`Query size (${Math.round(querySize / 1024)}KB) exceeds BigQuery limit. Reducing batch size from ${batchSize} to ${Math.floor(batchSize / 2)}`);
-            this.executeMergeQueryRecursively(recordKeys, Math.floor(batchSize / 2));
+            await this.executeMergeQueryRecursively(recordKeys, Math.floor(batchSize / 2));
             return;
           }
           try {
-            this.executeQuery(query);
+            await this.executeQuery(query);
             this.totalRecordsProcessed += currentBatch.length;
             console.log(`BigQuery MERGE completed successfully for ${currentBatch.length} records (Total processed: ${this.totalRecordsProcessed})`);
             if (remainingRecords.length > 0) {
@@ -3086,9 +2110,10 @@ OPTIONS(description="${this.description}")`;
               if (record[columnName] === void 0 || record[columnName] === null) {
                 columnValue = null;
               } else if (columnType.toUpperCase() == "DATE" && record[columnName] instanceof Date) {
-                columnValue = EnvironmentAdapter2.formatDate(record[columnName], "UTC", "yyyy-MM-dd");
+                columnValue = DateUtils2.formatDate(record[columnName]);
               } else if (columnType.toUpperCase() == "DATETIME" && record[columnName] instanceof Date) {
-                columnValue = EnvironmentAdapter2.formatDate(record[columnName], "UTC", "yyyy-MM-dd HH:mm:ss");
+                const isoString = record[columnName].toISOString();
+                columnValue = isoString.replace("T", " ").substring(0, 19);
               } else {
                 columnValue = this.obfuscateSpecialCharacters(record[columnName]);
               }
@@ -3123,53 +2148,36 @@ OPTIONS(description="${this.description}")`;
         //---- query -------------------------------------------------------
         /**
          * Executes Google BigQuery Query and returns a result
-         * 
-         * @param {query} string 
-         * 
-         * @return object
-         * 
+         *
+         * @param {query} string
+         *
+         * @return Promise<object>
+         *
          */
-        executeQuery(query) {
-          if (this.config.Environment.value === ENVIRONMENT2.APPS_SCRIPT) {
-            return BigQuery.Jobs.query(
-              { "query": query, useLegacySql: false },
-              this.config.ProjectID.value
-            );
-          }
-          if (this.config.Environment.value === ENVIRONMENT2.NODE) {
-            let result = void 0;
-            let error = void 0;
-            let bigqueryClient = null;
-            if (this.config.ServiceAccountJson && this.config.ServiceAccountJson.value) {
-              const { JWT } = require("google-auth-library");
-              const credentials = JSON.parse(this.config.ServiceAccountJson.value);
-              const authClient = new JWT({
-                email: credentials.client_email,
-                key: credentials.private_key,
-                scopes: ["https://www.googleapis.com/auth/bigquery"]
-              });
-              bigqueryClient = new BigQuery({
-                projectId: this.config.ProjectID.value || credentials.project_id,
-                authClient
-              });
-            } else {
-              throw new Error("Service account JSON is required to connect to Google BigQuery in Node.js environment");
-            }
-            const options = {
-              query,
-              useLegacySql: false
-            };
-            bigqueryClient.createQueryJob(options).then(([job]) => job.getQueryResults()).then(([rows]) => rows).then((value) => {
-              result = value;
-            }).catch((e) => {
-              error = e;
+        async executeQuery(query) {
+          let bigqueryClient = null;
+          if (this.config.ServiceAccountJson && this.config.ServiceAccountJson.value) {
+            const { JWT } = require("google-auth-library");
+            const credentials = JSON.parse(this.config.ServiceAccountJson.value);
+            const authClient = new JWT({
+              email: credentials.client_email,
+              key: credentials.private_key,
+              scopes: ["https://www.googleapis.com/auth/bigquery"]
             });
-            deasync.loopWhile(() => result === void 0 && error === void 0);
-            if (error !== void 0) {
-              throw error;
-            }
-            return result;
+            bigqueryClient = new BigQuery({
+              projectId: this.config.ProjectID.value || credentials.project_id,
+              authClient
+            });
+          } else {
+            throw new Error("Service account JSON is required to connect to Google BigQuery in Node.js environment");
           }
+          const options = {
+            query,
+            useLegacySql: false
+          };
+          const [job] = await bigqueryClient.createQueryJob(options);
+          const [rows] = await job.getQueryResults();
+          return rows;
         }
         //---- obfuscateSpecialCharacters ----------------------------------
         obfuscateSpecialCharacters(inputString) {
@@ -3265,7 +2273,7 @@ OPTIONS(description="${this.description}")`;
       };
     })();
     const AwsAthena = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
+      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils2, FileUtils: FileUtils2, DateUtils: DateUtils2, CryptoUtils: CryptoUtils2, AsyncUtils: AsyncUtils2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
       var AwsAthenaStorage = class AwsAthenaStorage extends AbstractStorage2 {
         //---- constructor -------------------------------------------------
         /**
@@ -3323,9 +2331,21 @@ OPTIONS(description="${this.description}")`;
           this.initAWS();
           this.updatedRecordsBuffer = {};
           this.existingColumns = {};
-          this.setupAthenaDatabase();
           this.uploadSid = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.]/g, "") + "_" + Math.random().toString(36).substring(2, 15);
         }
+        //---- init --------------------------------------------------------
+        /**
+         * Initializing storage
+         */
+        async init() {
+          const success = await this.setupAthenaDatabase();
+          if (success) {
+            console.log("Database created or already exists");
+          } else {
+            throw new Error("Failed to create database");
+          }
+        }
+        //----------------------------------------------------------------
         //---- initAWS ----------------------------------------------------
         /**
          * Initialize AWS SDK clients
@@ -3357,61 +2377,58 @@ OPTIONS(description="${this.description}")`;
         /**
          * Create Athena database if it doesn't exist
          */
-        createDatabaseIfNotExists() {
+        async createDatabaseIfNotExists() {
           const params = {
             QueryString: `CREATE SCHEMA IF NOT EXISTS \`${this.config.AthenaDatabaseName.value}\``,
             ResultConfiguration: {
               OutputLocation: this.config.AthenaOutputLocation.value
             }
           };
-          return this.executeQuery(params, "ddl").then(() => {
-            this.config.logMessage(`Database ${this.config.AthenaDatabaseName.value} created or already exists`);
-            return true;
-          });
+          await this.executeQuery(params, "ddl");
+          this.config.logMessage(`Database ${this.config.AthenaDatabaseName.value} created or already exists`);
+          return true;
         }
         //---- checkTableExists ------------------------------------------
         /**
          * Check if the target table exists in Athena
          */
-        checkTableExists() {
+        async checkTableExists() {
           const params = {
             QueryString: `SHOW TABLES IN \`${this.config.AthenaDatabaseName.value}\` LIKE '${this.config.DestinationTableName.value}'`,
             ResultConfiguration: {
               OutputLocation: this.config.AthenaOutputLocation.value
             }
           };
-          return this.executeQuery(params, "ddl").then((results) => {
+          try {
+            const results = await this.executeQuery(params, "ddl");
             if (results && results.length > 0) {
-              return this.getTableSchema();
+              return await this.getTableSchema();
             }
-            return this.createTargetTable();
-          }).catch(() => {
-            return this.createTargetTable();
-          });
+            return await this.createTargetTable();
+          } catch {
+            return await this.createTargetTable();
+          }
         }
         //---- getTableSchema -------------------------------------------
         /**
          * Get the schema of the existing table
          */
-        getTableSchema() {
+        async getTableSchema() {
           const params = {
             QueryString: `SHOW COLUMNS IN \`${this.config.AthenaDatabaseName.value}\`.\`${this.config.DestinationTableName.value}\``,
             ResultConfiguration: {
               OutputLocation: this.config.AthenaOutputLocation.value
             }
           };
-          return this.executeQuery(params, "ddl").then((results) => {
-            let columns = {};
-            if (results && results.length > 0) {
-              results.forEach((row) => {
-                columns[row] = this.getColumnType(row);
-              });
-            }
-            this.existingColumns = columns;
-            return columns;
-          }).catch((error) => {
-            return {};
-          });
+          const results = await this.executeQuery(params, "ddl");
+          let columns = {};
+          if (results && results.length > 0) {
+            results.forEach((row) => {
+              columns[row] = this.getColumnType(row);
+            });
+          }
+          this.existingColumns = columns;
+          return columns;
         }
         //---- createTargetTable ----------------------------------------------
         /**
@@ -3501,45 +2518,42 @@ OPTIONS(description="${this.description}")`;
          * @param {Array} data - Array of objects with records to save
          * @returns {Promise}
          */
-        saveData(data) {
-          let done = false;
-          this.checkTableExists().then(() => {
-            const allColumns = /* @__PURE__ */ new Set();
-            if (data.length > 0) {
-              data.forEach((row) => {
-                Object.keys(row).forEach((column) => allColumns.add(column));
-              });
-            }
-            if (this.config.Fields.value) {
-              this.getSelectedFields().forEach((columnName) => {
-                if (columnName && !allColumns.has(columnName)) {
-                  allColumns.add(columnName);
-                  if (data.length > 0) {
-                    data.forEach((row) => {
-                      if (!row[columnName]) {
-                        row[columnName] = "";
-                      }
-                    });
-                  }
+        async saveData(data) {
+          await this.checkTableExists();
+          const allColumns = /* @__PURE__ */ new Set();
+          if (data.length > 0) {
+            data.forEach((row) => {
+              Object.keys(row).forEach((column) => allColumns.add(column));
+            });
+          }
+          if (this.config.Fields.value) {
+            this.getSelectedFields().forEach((columnName) => {
+              if (columnName && !allColumns.has(columnName)) {
+                allColumns.add(columnName);
+                if (data.length > 0) {
+                  data.forEach((row) => {
+                    if (!row[columnName]) {
+                      row[columnName] = "";
+                    }
+                  });
                 }
-              });
-            }
-            const existingColumnsSet = new Set(Object.keys(this.existingColumns));
-            const newColumns = Array.from(allColumns).filter((column) => !existingColumnsSet.has(column));
-            if (newColumns.length > 0) {
-              return this.addNewColumns(newColumns);
-            }
-            return Promise.resolve();
-          }).then(() => {
-            if (data.length === 0) {
-              done = true;
-              return;
-            }
-            this.config.logMessage(`Saving ${data.length} records to Athena`);
-            const tempFolder = `${this.config.S3Prefix.value}_temp/${this.uploadSid}`;
-            return this.uploadDataToS3TempFolder(data, tempFolder).then(() => this.createTempTable(tempFolder, this.uploadSid)).then((tempTableName) => this.mergeDataFromTempTable(tempTableName, this.uploadSid)).then((tempTableName) => this.cleanupTempResources(tempFolder, tempTableName)).then(() => done = true);
-          });
-          deasync.loopWhile(() => !done);
+              }
+            });
+          }
+          const existingColumnsSet = new Set(Object.keys(this.existingColumns));
+          const newColumns = Array.from(allColumns).filter((column) => !existingColumnsSet.has(column));
+          if (newColumns.length > 0) {
+            await this.addNewColumns(newColumns);
+          }
+          if (data.length === 0) {
+            return;
+          }
+          this.config.logMessage(`Saving ${data.length} records to Athena`);
+          const tempFolder = `${this.config.S3Prefix.value}_temp/${this.uploadSid}`;
+          await this.uploadDataToS3TempFolder(data, tempFolder);
+          const tempTableName = await this.createTempTable(tempFolder, this.uploadSid);
+          await this.mergeDataFromTempTable(tempTableName, this.uploadSid);
+          await this.cleanupTempResources(tempFolder, tempTableName);
         }
         //---- uploadDataToS3TempFolder ---------------------------------
         /**
@@ -3728,6 +2742,7 @@ OPTIONS(description="${this.description}")`;
             QueryExecutionId: queryExecutionId
           };
           return this.athenaClient.send(new GetQueryExecutionCommand(params)).then((data) => {
+            var _a;
             const state = data.QueryExecution.Status.State;
             if (state === "SUCCEEDED") {
               return new Promise((resolve) => {
@@ -3736,6 +2751,7 @@ OPTIONS(description="${this.description}")`;
                 }, 3e3);
               });
             } else if (state === "FAILED" || state === "CANCELLED") {
+              this.config.logMessage(`Query ${queryExecutionId} ${state}: ${data.QueryExecution.Status.StateChangeReason || ""}. Error: ${((_a = data.QueryExecution.Status.Error) == null ? void 0 : _a.Message) || ""}`);
               throw new Error(`Query ${state}: ${data.QueryExecution.Status.StateChangeReason || ""}`);
             } else {
               return new Promise((resolve) => {
@@ -3895,12 +2911,11 @@ OPTIONS(description="${this.description}")`;
       };
     })();
     const Storages = {
-      GoogleSheets,
       GoogleBigQuery,
       AwsAthena
     };
     const XAds = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
+      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils2, FileUtils: FileUtils2, DateUtils: DateUtils2, CryptoUtils: CryptoUtils2, AsyncUtils: AsyncUtils2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
       const XAdsHelper = {
         /**
          * Parse fields string into a structured object
@@ -4794,34 +3809,34 @@ OPTIONS(description="${this.description}")`;
          * @param {string} [opts.end_time]
          * @returns {Array<Object>}
          */
-        fetchData({ nodeName, accountId, fields = [], start_time, end_time }) {
-          EnvironmentAdapter2.sleep(this.config.AdsApiDelay.value * 1e3);
+        async fetchData({ nodeName, accountId, fields = [], start_time, end_time }) {
+          await AsyncUtils2.delay(this.config.AdsApiDelay.value * 1e3);
           switch (nodeName) {
             case "accounts": {
-              const resp = this._getData(`accounts/${accountId}`, "accounts", fields);
+              const resp = await this._getData(`accounts/${accountId}`, "accounts", fields);
               return [resp.data];
             }
             case "campaigns":
             case "line_items":
             case "promoted_tweets":
             case "tweets":
-              return this._catalogFetch({
+              return await this._catalogFetch({
                 nodeName,
                 accountId,
                 fields,
                 pageSize: this.config.DataMaxCount.value
               });
             case "cards":
-              return this._catalogFetch({
+              return await this._catalogFetch({
                 nodeName,
                 accountId,
                 fields,
                 pageSize: this.config.CardsMaxCountPerRequest.value
               });
             case "cards_all":
-              return this._fetchAllCards(accountId, fields);
+              return await this._fetchAllCards(accountId, fields);
             case "stats":
-              return this._timeSeriesFetch({ nodeName, accountId, fields, start_time, end_time });
+              return await this._timeSeriesFetch({ nodeName, accountId, fields, start_time, end_time });
             default:
               throw new ConfigurationError(`Unknown node: ${nodeName}`);
           }
@@ -4857,7 +3872,7 @@ OPTIONS(description="${this.description}")`;
         /**
          * Shared logic for non-time-series endpoints
          */
-        _catalogFetch({ nodeName, accountId, fields, pageSize }) {
+        async _catalogFetch({ nodeName, accountId, fields, pageSize }) {
           const uniqueKeys = this.fieldsSchema[nodeName].uniqueKeys || [];
           const missingKeys = uniqueKeys.filter((key) => !fields.includes(key));
           if (missingKeys.length > 0) {
@@ -4881,7 +3896,7 @@ OPTIONS(description="${this.description}")`;
             console.log("deleting cached tweets");
             this._tweetsCache.delete(accountId);
           }
-          let all = this._fetchPages({
+          let all = await this._fetchPages({
             accountId,
             nodeName,
             fields,
@@ -4905,7 +3920,7 @@ OPTIONS(description="${this.description}")`;
         /**
          * Shared pagination logic
          */
-        _fetchPages({ accountId, nodeName, fields, extraParams = {}, pageSize }) {
+        async _fetchPages({ accountId, nodeName, fields, extraParams = {}, pageSize }) {
           const all = [];
           let cursor = null;
           const MAX_PAGES = 100;
@@ -4916,7 +3931,7 @@ OPTIONS(description="${this.description}")`;
               ...extraParams,
               ...cursor ? { cursor } : {}
             };
-            const resp = this._getData(
+            const resp = await this._getData(
               `accounts/${accountId}/${nodeName}`,
               nodeName,
               fields,
@@ -4937,15 +3952,15 @@ OPTIONS(description="${this.description}")`;
          * Fetch all cards by first collecting URIs from tweets,
          * then calling the cards/all endpoint in chunks.
          */
-        _fetchAllCards(accountId, fields) {
-          const tweets = this.fetchData({ nodeName: "tweets", accountId, fields: ["id", "card_uri"] });
+        async _fetchAllCards(accountId, fields) {
+          const tweets = await this.fetchData({ nodeName: "tweets", accountId, fields: ["id", "card_uri"] });
           const uris = tweets.map((t) => t.card_uri).filter(Boolean);
           if (!uris.length) return [];
           const all = [];
           const chunkSize = this.config.CardsMaxCountPerRequest.value;
           for (let i = 0; i < uris.length; i += chunkSize) {
             const chunk = uris.slice(i, i + chunkSize);
-            const resp = this._getData(
+            const resp = await this._getData(
               `accounts/${accountId}/cards/all`,
               "cards_all",
               fields,
@@ -4962,18 +3977,18 @@ OPTIONS(description="${this.description}")`;
         /**
          * Stats are time-series and need flattening of `metrics`
          */
-        _timeSeriesFetch({ nodeName, accountId, fields, start_time, end_time }) {
+        async _timeSeriesFetch({ nodeName, accountId, fields, start_time, end_time }) {
           const uniqueKeys = this.fieldsSchema[nodeName].uniqueKeys || [];
           const missingKeys = uniqueKeys.filter((key) => !fields.includes(key));
           if (missingKeys.length > 0) {
             throw new Error(`Missing required unique fields for endpoint '${nodeName}'. Missing fields: ${missingKeys.join(", ")}`);
           }
-          const promos = this.fetchData({ nodeName: "promoted_tweets", accountId, fields: ["id"] });
+          const promos = await this.fetchData({ nodeName: "promoted_tweets", accountId, fields: ["id"] });
           const ids = promos.map((r) => r.id);
           if (!ids.length) return [];
           const e = new Date(end_time);
           e.setDate(e.getDate() + 1);
-          const endStr = EnvironmentAdapter2.formatDate(e, "UTC", "yyyy-MM-dd");
+          const endStr = DateUtils2.formatDate(e);
           const result = [];
           for (let i = 0; i < ids.length; i += this.config.StatsMaxEntityIds.value) {
             const batch = ids.slice(i, i + this.config.StatsMaxEntityIds.value).join(",");
@@ -4986,7 +4001,7 @@ OPTIONS(description="${this.description}")`;
               end_time: endStr
             };
             for (const placement of ["ALL_ON_TWITTER", "PUBLISHER_NETWORK"]) {
-              const raw = this._rawFetch(`stats/accounts/${accountId}`, { ...common, placement });
+              const raw = await this._rawFetch(`stats/accounts/${accountId}`, { ...common, placement });
               const arr = Array.isArray(raw.data) ? raw.data : [raw.data];
               arr.forEach((h) => {
                 var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
@@ -5022,18 +4037,19 @@ OPTIONS(description="${this.description}")`;
         /**
          * Pull JSON from the Ads API (raw, no field-filter).
          */
-        _rawFetch(path, params = {}) {
+        async _rawFetch(path, params = {}) {
           const url = `${this.BASE_URL}${this.config.Version.value}/${path}`;
           const qs = Object.keys(params).length ? "?" + Object.entries(params).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&") : "";
           const finalUrl = url + qs;
           const oauth = this._generateOAuthHeader({ method: "GET", url, params });
-          EnvironmentAdapter2.sleep(1e3);
-          const resp = this.urlFetchWithRetry(finalUrl, {
+          await AsyncUtils2.delay(1e3);
+          const resp = await this.urlFetchWithRetry(finalUrl, {
             method: "GET",
             headers: { Authorization: oauth, "Content-Type": "application/json" },
             muteHttpExceptions: true
           });
-          return JSON.parse(resp.getContentText());
+          const text = await resp.getContentText();
+          return JSON.parse(text);
         }
         /**
          * Determines if a X Ads API error is valid for retry
@@ -5056,8 +4072,8 @@ OPTIONS(description="${this.description}")`;
           }
           return false;
         }
-        _getData(path, nodeName, fields, extraParams = {}) {
-          const json = this._rawFetch(path, extraParams);
+        async _getData(path, nodeName, fields, extraParams = {}) {
+          const json = await this._rawFetch(path, extraParams);
           if (!json.data) return json;
           const arr = Array.isArray(json.data) ? json.data : [json.data];
           const filtered = this._filterBySchema(arr, nodeName, fields);
@@ -5096,7 +4112,7 @@ OPTIONS(description="${this.description}")`;
           const { ConsumerKey, ConsumerSecret, AccessToken, AccessTokenSecret } = this.config;
           const oauth = {
             oauth_consumer_key: ConsumerKey.value,
-            oauth_nonce: EnvironmentAdapter2.getUuid().replace(/-/g, ""),
+            oauth_nonce: CryptoUtils2.getUuid().replace(/-/g, ""),
             oauth_signature_method: "HMAC-SHA1",
             oauth_timestamp: Math.floor(Date.now() / 1e3),
             oauth_token: AccessToken.value,
@@ -5111,9 +4127,9 @@ OPTIONS(description="${this.description}")`;
             )
           ].join("&");
           const signingKey = encodeURIComponent(ConsumerSecret.value) + "&" + encodeURIComponent(AccessTokenSecret.value);
-          oauth.oauth_signature = EnvironmentAdapter2.base64Encode(
-            EnvironmentAdapter2.computeHmacSignature(
-              EnvironmentAdapter2.MacAlgorithm.HMAC_SHA_1,
+          oauth.oauth_signature = CryptoUtils2.base64Encode(
+            CryptoUtils2.computeHmacSignature(
+              CryptoUtils2.MacAlgorithm.HMAC_SHA_1,
               baseString,
               signingKey
             )
@@ -5129,7 +4145,7 @@ OPTIONS(description="${this.description}")`;
         }
       };
       var XAdsConnector = class XAdsConnector extends AbstractConnector2 {
-        constructor(config, source, storageName = "GoogleSheetsStorage", runConfig = null) {
+        constructor(config, source, storageName = "GoogleBigQueryStorage", runConfig = null) {
           super(config, source, null, runConfig);
           this.storageName = storageName;
         }
@@ -5137,12 +4153,12 @@ OPTIONS(description="${this.description}")`;
          * Main method - entry point for the import process
          * Processes all nodes defined in the fields configuration
          */
-        startImportProcess() {
+        async startImportProcess() {
           const fields = XAdsHelper.parseFields(this.config.Fields.value);
           const accountIds = XAdsHelper.parseAccountIds(this.config.AccountIDs.value);
           for (const accountId of accountIds) {
             for (const nodeName in fields) {
-              this.processNode({
+              await this.processNode({
                 nodeName,
                 accountId,
                 fields: fields[nodeName] || []
@@ -5158,15 +4174,15 @@ OPTIONS(description="${this.description}")`;
          * @param {string} options.accountId - Account ID
          * @param {Array<string>} options.fields - Array of fields to fetch
          */
-        processNode({ nodeName, accountId, fields }) {
+        async processNode({ nodeName, accountId, fields }) {
           if (this.source.fieldsSchema[nodeName].isTimeSeries) {
-            this.processTimeSeriesNode({
+            await this.processTimeSeriesNode({
               nodeName,
               accountId,
               fields
             });
           } else {
-            this.processCatalogNode({
+            await this.processCatalogNode({
               nodeName,
               accountId,
               fields
@@ -5181,7 +4197,7 @@ OPTIONS(description="${this.description}")`;
          * @param {Array<string>} options.fields - Array of fields to fetch
          * @param {Object} options.storage - Storage instance
          */
-        processTimeSeriesNode({ nodeName, accountId, fields }) {
+        async processTimeSeriesNode({ nodeName, accountId, fields }) {
           var _a;
           const [startDate, daysToFetch] = this.getStartDateAndDaysToFetch();
           if (daysToFetch <= 0) {
@@ -5191,12 +4207,13 @@ OPTIONS(description="${this.description}")`;
           for (let i = 0; i < daysToFetch; i++) {
             const currentDate = new Date(startDate);
             currentDate.setDate(currentDate.getDate() + i);
-            const formattedDate = EnvironmentAdapter2.formatDate(currentDate, "UTC", "yyyy-MM-dd");
-            const data = this.source.fetchData({ nodeName, accountId, start_time: formattedDate, end_time: formattedDate, fields });
+            const formattedDate = DateUtils2.formatDate(currentDate);
+            const data = await this.source.fetchData({ nodeName, accountId, start_time: formattedDate, end_time: formattedDate, fields });
             this.config.logMessage(data.length ? `${data.length} rows of ${nodeName} were fetched for ${accountId} on ${formattedDate}` : `No records have been fetched`);
             if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
               const preparedData = data.length ? this.addMissingFieldsToData(data, fields) : data;
-              this.getStorageByNode(nodeName).saveData(preparedData);
+              const storage = await this.getStorageByNode(nodeName);
+              await storage.saveData(preparedData);
             }
             if (this.runConfig.type === RUN_CONFIG_TYPE2.INCREMENTAL) {
               this.config.updateLastRequstedDate(currentDate);
@@ -5211,13 +4228,14 @@ OPTIONS(description="${this.description}")`;
          * @param {Array<string>} options.fields - Array of fields to fetch
          * @param {Object} options.storage - Storage instance
          */
-        processCatalogNode({ nodeName, accountId, fields }) {
+        async processCatalogNode({ nodeName, accountId, fields }) {
           var _a;
-          const data = this.source.fetchData({ nodeName, accountId, fields });
+          const data = await this.source.fetchData({ nodeName, accountId, fields });
           this.config.logMessage(data.length ? `${data.length} rows of ${nodeName} were fetched for ${accountId}` : `No records have been fetched`);
           if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
             const preparedData = data.length ? this.addMissingFieldsToData(data, fields) : data;
-            this.getStorageByNode(nodeName).saveData(preparedData);
+            const storage = await this.getStorageByNode(nodeName);
+            await storage.saveData(preparedData);
           }
         }
         /**
@@ -5225,7 +4243,7 @@ OPTIONS(description="${this.description}")`;
          * @param {string} nodeName - Name of the node
          * @returns {Object} Storage instance
          */
-        getStorageByNode(nodeName) {
+        async getStorageByNode(nodeName) {
           if (!("storages" in this)) {
             this.storages = {};
           }
@@ -5243,6 +4261,7 @@ OPTIONS(description="${this.description}")`;
               this.source.fieldsSchema[nodeName].fields,
               `${this.source.fieldsSchema[nodeName].description} ${this.source.fieldsSchema[nodeName].documentation}`
             );
+            await this.storages[nodeName].init();
           }
           return this.storages[nodeName];
         }
@@ -5259,7 +4278,7 @@ OPTIONS(description="${this.description}")`;
       };
     })();
     const TikTokAds = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
+      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils2, FileUtils: FileUtils2, DateUtils: DateUtils2, CryptoUtils: CryptoUtils2, AsyncUtils: AsyncUtils2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
       class TiktokMarketingApiProvider {
         constructor(appId, accessToken, appSecret, isSandbox = false) {
           this.BASE_URL = "https://business-api.tiktok.com/open_api/";
@@ -5283,7 +4302,7 @@ OPTIONS(description="${this.description}")`;
         getApiVersion() {
           return this.API_VERSION;
         }
-        makeRequest(options) {
+        async makeRequest(options) {
           const { url, method, data } = options;
           const headers = {
             "Access-Token": this.accessToken,
@@ -5292,21 +4311,21 @@ OPTIONS(description="${this.description}")`;
           let backoff = this.INITIAL_BACKOFF;
           for (let retries = 0; retries < this.MAX_RETRIES; retries++) {
             try {
-              const response = EnvironmentAdapter2.fetch(url, {
+              const response = await HttpUtils2.fetch(url, {
                 method,
                 headers,
-                body: data ? JSON.stringify(data) : null,
-                muteHttpExceptions: true
+                body: data ? JSON.stringify(data) : null
               });
               const responseCode = response.getResponseCode();
+              const text = await response.getContentText();
               if (responseCode !== this.SUCCESS_RESPONSE_CODE) {
-                throw new Error(`TikTok API error: ${response.getContentText()}`);
+                throw new Error(`TikTok API error: ${text}`);
               }
-              const jsonData = JSON.parse(response.getContentText());
+              const jsonData = JSON.parse(text);
               if (jsonData.code !== this.SUCCESS_CODE) {
                 if (jsonData.code === this.RATE_LIMIT_CODE) {
                   console.error("TikTok Marketing API rate limit exceeded. Retrying...");
-                  EnvironmentAdapter2.sleep(backoff);
+                  await AsyncUtils2.delay(backoff);
                   backoff *= 2;
                   continue;
                 }
@@ -5315,7 +4334,7 @@ OPTIONS(description="${this.description}")`;
               return jsonData;
             } catch (error) {
               if (retries < this.MAX_RETRIES - 1 && error.message.includes("rate limit")) {
-                EnvironmentAdapter2.sleep(backoff);
+                await AsyncUtils2.delay(backoff);
                 backoff *= 2;
               } else {
                 throw error;
@@ -5323,7 +4342,7 @@ OPTIONS(description="${this.description}")`;
             }
           }
         }
-        handlePagination(endpoint, params = {}) {
+        async handlePagination(endpoint, params = {}) {
           let allData = [];
           let page = 1;
           let hasMorePages = true;
@@ -5331,7 +4350,7 @@ OPTIONS(description="${this.description}")`;
           while (hasMorePages) {
             const paginatedParams = { ...params, page, page_size: pageSize };
             const url = this.buildUrl(endpoint, paginatedParams);
-            const response = this.makeRequest({ url, method: "GET" });
+            const response = await this.makeRequest({ url, method: "GET" });
             const pageData = response.data.list || [];
             allData = allData.concat(pageData);
             const total = response.data.page_info ? response.data.page_info.total_number : 0;
@@ -5339,7 +4358,7 @@ OPTIONS(description="${this.description}")`;
             hasMorePages = currentCount < total && pageData.length > 0;
             page++;
             if (hasMorePages) {
-              EnvironmentAdapter2.sleep(100);
+              await AsyncUtils2.delay(100);
             }
           }
           return allData;
@@ -6422,7 +5441,7 @@ OPTIONS(description="${this.description}")`;
          * @param {Date} endDate - End date for time-series data (optional)
          * @return {array} - Array of data objects
          */
-        fetchData(nodeName, advertiserId, fields, startDate = null, endDate = null) {
+        async fetchData(nodeName, advertiserId, fields, startDate = null, endDate = null) {
           if (!this.fieldsSchema[nodeName]) {
             throw new Error(`Unknown node type: ${nodeName}`);
           }
@@ -6443,8 +5462,8 @@ OPTIONS(description="${this.description}")`;
           let formattedStartDate = null;
           let formattedEndDate = null;
           if (startDate) {
-            formattedStartDate = EnvironmentAdapter2.formatDate(startDate, "UTC", "yyyy-MM-dd");
-            formattedEndDate = endDate ? EnvironmentAdapter2.formatDate(endDate, "UTC", "yyyy-MM-dd") : formattedStartDate;
+            formattedStartDate = DateUtils2.formatDate(startDate);
+            formattedEndDate = endDate ? DateUtils2.formatDate(endDate) : formattedStartDate;
           }
           let filtering = null;
           if (this.config.IncludeDeleted && this.config.IncludeDeleted.value) {
@@ -6666,11 +5685,11 @@ OPTIONS(description="${this.description}")`;
         }
       };
       var TikTokAdsConnector = class TikTokAdsConnector extends AbstractConnector2 {
-        constructor(config, source, storageName = "GoogleSheetsStorage", runConfig = null) {
+        constructor(config, source, storageName = "GoogleBigQueryStorage", runConfig = null) {
           super(config, source, null, runConfig);
           this.storageName = storageName;
         }
-        startImportProcess() {
+        async startImportProcess() {
           try {
             let advertiserIds = TikTokAdsHelper.parseAdvertiserIds(this.config.AdvertiserIDs.value || "");
             if (!advertiserIds || advertiserIds.length === 0) {
@@ -6694,7 +5713,7 @@ OPTIONS(description="${this.description}")`;
               }
             }
             if (Object.keys(catalogNodes).length > 0) {
-              this.importCatalogData(catalogNodes, advertiserIds);
+              await this.importCatalogData(catalogNodes, advertiserIds);
             }
             if (Object.keys(timeSeriesNodes).length > 0) {
               try {
@@ -6703,7 +5722,7 @@ OPTIONS(description="${this.description}")`;
                   this.config.logMessage("There is nothing to import in this data range");
                   return;
                 }
-                this.startImportProcessOfTimeSeriesData(advertiserIds, timeSeriesNodes, startDate, daysToFetch);
+                await this.startImportProcessOfTimeSeriesData(advertiserIds, timeSeriesNodes, startDate, daysToFetch);
               } catch (error) {
                 this.config.logMessage(`Error determining date range: ${error.message}`);
                 console.error(error.stack);
@@ -6722,35 +5741,36 @@ OPTIONS(description="${this.description}")`;
         }
         /**
          * Imports all catalog (non-time-series) data types
-         * 
+         *
          * @param {object} catalogNodes - Object with node names as keys and field arrays as values
          * @param {array} advertiserIds - List of advertiser IDs to fetch data for
          */
-        importCatalogData(catalogNodes, advertiserIds) {
+        async importCatalogData(catalogNodes, advertiserIds) {
           for (var nodeName in catalogNodes) {
             this.config.logMessage(`Starting import for ${nodeName} data...`);
-            this.startImportProcessOfCatalogData(nodeName, advertiserIds, catalogNodes[nodeName]);
+            await this.startImportProcessOfCatalogData(nodeName, advertiserIds, catalogNodes[nodeName]);
           }
         }
         /**
          * Imports catalog (not time series) data
-         * 
+         *
          * @param {string} nodeName - Node name
          * @param {array} advertiserIds - List of advertiser IDs
          * @param {array} fields - List of fields
          */
-        startImportProcessOfCatalogData(nodeName, advertiserIds, fields) {
+        async startImportProcessOfCatalogData(nodeName, advertiserIds, fields) {
           var _a;
           this.config.logMessage(`Fetching all available fields for ${nodeName}`);
           for (var i in advertiserIds) {
             let advertiserId = advertiserIds[i];
             try {
-              let data = this.source.fetchData(nodeName, advertiserId, fields);
+              let data = await this.source.fetchData(nodeName, advertiserId, fields);
               this.config.logMessage(data.length ? `${data.length} rows of ${nodeName} were fetched for advertiser ${advertiserId}` : `No records have been fetched`);
               if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
                 try {
                   const preparedData = data.length ? this.addMissingFieldsToData(data, fields) : data;
-                  this.getStorageByNode(nodeName).saveData(preparedData);
+                  const storage = await this.getStorageByNode(nodeName);
+                  await storage.saveData(preparedData);
                 } catch (storageError) {
                   this.config.logMessage(`Error saving data to storage: ${storageError.message}`);
                   console.error(`Error details: ${storageError.stack}`);
@@ -6764,29 +5784,30 @@ OPTIONS(description="${this.description}")`;
         }
         /**
          * Imports time series data
-         * 
+         *
          * @param {array} advertiserIds - List of advertiser IDs
          * @param {object} timeSeriesNodes - Object of properties, each is array of fields
          * @param {Date} startDate - Start date
          * @param {number} daysToFetch - Number of days to fetch
          */
-        startImportProcessOfTimeSeriesData(advertiserIds, timeSeriesNodes, startDate, daysToFetch) {
+        async startImportProcessOfTimeSeriesData(advertiserIds, timeSeriesNodes, startDate, daysToFetch) {
           var _a;
           for (var daysShift = 0; daysShift < daysToFetch; daysShift++) {
             const currentDate = new Date(startDate);
             currentDate.setDate(currentDate.getDate() + daysShift);
-            const formattedDate = EnvironmentAdapter2.formatDate(currentDate, "UTC", "yyyy-MM-dd");
+            const formattedDate = DateUtils2.formatDate(currentDate);
             this.config.logMessage(`Processing data for date: ${formattedDate}`);
             for (let advertiserId of advertiserIds) {
               for (var nodeName in timeSeriesNodes) {
                 try {
                   this.config.logMessage(`Start importing data for ${formattedDate}: ${advertiserId}/${nodeName}`);
-                  let data = this.source.fetchData(nodeName, advertiserId, timeSeriesNodes[nodeName], currentDate);
+                  let data = await this.source.fetchData(nodeName, advertiserId, timeSeriesNodes[nodeName], currentDate);
                   this.config.logMessage(data.length ? `${data.length} records were fetched` : `No records have been fetched`);
                   if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
                     try {
                       const preparedData = data.length ? this.addMissingFieldsToData(data, timeSeriesNodes[nodeName]) : data;
-                      this.getStorageByNode(nodeName).saveData(preparedData);
+                      const storage = await this.getStorageByNode(nodeName);
+                      await storage.saveData(preparedData);
                     } catch (storageError) {
                       this.config.logMessage(`Error saving data to storage: ${storageError.message}`);
                       console.error(`Error details: ${storageError.stack}`);
@@ -6810,7 +5831,7 @@ OPTIONS(description="${this.description}")`;
          * @param {array} requestedFields - List of requested fields
          * @return {AbstractStorage} - Storage instance
          */
-        getStorageByNode(nodeName) {
+        async getStorageByNode(nodeName) {
           if (!("storages" in this)) {
             this.storages = {};
           }
@@ -6832,6 +5853,7 @@ OPTIONS(description="${this.description}")`;
               this.source.fieldsSchema[nodeName]["fields"] || {},
               `${this.source.fieldsSchema[nodeName]["description"]} ${this.source.fieldsSchema[nodeName]["documentation"]}`
             );
+            await this.storages[nodeName].init();
           }
           return this.storages[nodeName];
         }
@@ -6849,35 +5871,9 @@ OPTIONS(description="${this.description}")`;
           this.config.logMessage(`Cleaning up data older than ${keepDays} days...`);
           const cutoffDate = /* @__PURE__ */ new Date();
           cutoffDate.setDate(cutoffDate.getDate() - keepDays);
-          const formattedCutoffDate = EnvironmentAdapter2.formatDate(cutoffDate, "UTC", "yyyy-MM-dd");
+          DateUtils2.formatDate(cutoffDate);
           for (var nodeName in this.source.fieldsSchema) {
-            if ("fields" in this.source.fieldsSchema[nodeName] && ("date_start" in this.source.fieldsSchema[nodeName]["fields"] || "stat_time_day" in this.source.fieldsSchema[nodeName]["fields"])) {
-              try {
-                const storage = this.getStorageByNode(nodeName);
-                if (storage instanceof GoogleSheetsStorage) {
-                  const dateField = this.source.fieldsSchema[nodeName]["fields"]["date_start"] ? "date_start" : "stat_time_day";
-                  let keysToDelete = [];
-                  for (const uniqueKey in storage.values) {
-                    const record = storage.values[uniqueKey];
-                    const rowDate = record[dateField];
-                    if (rowDate && rowDate < cutoffDate) {
-                      keysToDelete.push(uniqueKey);
-                    }
-                  }
-                  let deletedCount = 0;
-                  for (const key of keysToDelete) {
-                    storage.deleteRecord(key);
-                    deletedCount++;
-                  }
-                  if (deletedCount > 0) {
-                    this.config.logMessage(`Deleted ${deletedCount} rows from ${nodeName} that were older than ${formattedCutoffDate}`);
-                  }
-                }
-              } catch (error) {
-                this.config.logMessage(`Error cleaning up old data from ${nodeName}: ${error.message}`);
-                console.error(`Error details: ${error.stack}`);
-              }
-            }
+            if ("fields" in this.source.fieldsSchema[nodeName] && ("date_start" in this.source.fieldsSchema[nodeName]["fields"] || "stat_time_day" in this.source.fieldsSchema[nodeName]["fields"])) ;
           }
         }
       };
@@ -6894,7 +5890,7 @@ OPTIONS(description="${this.description}")`;
       };
     })();
     const RedditAds = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
+      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils2, FileUtils: FileUtils2, DateUtils: DateUtils2, CryptoUtils: CryptoUtils2, AsyncUtils: AsyncUtils2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
       const RedditAdsHelper = {
         /**
          * Parse fields string into a structured object
@@ -9930,7 +8926,7 @@ OPTIONS(description="${this.description}")`;
          * @param {Date|null} startDate - The start date for data fetching.
          * @returns {Array} An array of data records.
          */
-        fetchData(nodeName, accountId, fields, startDate = null) {
+        async fetchData(nodeName, accountId, fields, startDate = null) {
           var _a;
           console.log(`Fetching data from ${nodeName}/${accountId} for ${startDate}`);
           const uniqueKeys = ((_a = this.fieldsSchema[nodeName]) == null ? void 0 : _a.uniqueKeys) || [];
@@ -9938,7 +8934,7 @@ OPTIONS(description="${this.description}")`;
           if (missingKeys.length > 0) {
             throw new Error(`Missing required unique fields for endpoint '${nodeName}'. Missing fields: ${missingKeys.join(", ")}`);
           }
-          const tokenResponse = this.getRedditAccessToken(
+          const tokenResponse = await this.getRedditAccessToken(
             this.config.ClientId.value,
             this.config.ClientSecret.value,
             this.config.RedirectUri.value,
@@ -9948,7 +8944,7 @@ OPTIONS(description="${this.description}")`;
             this.config.AccessToken.value = tokenResponse.accessToken;
           }
           const baseUrl = "https://ads-api.reddit.com/api/v3/";
-          let formattedDate = startDate ? EnvironmentAdapter2.formatDate(startDate, "UTC", "yyyy-MM-dd") : null;
+          let formattedDate = startDate ? DateUtils2.formatDate(startDate) : null;
           let headers = {
             "Accept": "application/json",
             "User-Agent": this.config.UserAgent.value,
@@ -9974,8 +8970,9 @@ OPTIONS(description="${this.description}")`;
           let nextPageURL = finalUrl;
           while (nextPageURL) {
             try {
-              const response = this.urlFetchWithRetry(nextPageURL, options);
-              const jsonData = JSON.parse(response.getContentText());
+              const response = await this.urlFetchWithRetry(nextPageURL, options);
+              const text = await response.getContentText();
+              const jsonData = JSON.parse(text);
               if ("data" in jsonData) {
                 nextPageURL = jsonData.pagination ? jsonData.pagination.next_url : null;
                 if (jsonData && jsonData.data && jsonData.data.metrics) {
@@ -9992,7 +8989,7 @@ OPTIONS(description="${this.description}")`;
               }
             } catch (error) {
               if (error.statusCode === HTTP_STATUS2.UNAUTHORIZED) {
-                const newTokenResponse = this.getRedditAccessToken(
+                const newTokenResponse = await this.getRedditAccessToken(
                   this.config.ClientId.value,
                   this.config.ClientSecret.value,
                   this.config.RedirectUri.value,
@@ -10019,12 +9016,12 @@ OPTIONS(description="${this.description}")`;
          * @param {string} refreshToken - The refresh token.
          * @returns {Object} An object with a success flag and either the access token or an error message.
          */
-        getRedditAccessToken(clientId, clientSecret, redirectUri, refreshToken) {
+        async getRedditAccessToken(clientId, clientSecret, redirectUri, refreshToken) {
           const url = "https://www.reddit.com/api/v1/access_token";
           const headers = {
             "Content-Type": "application/x-www-form-urlencoded",
             "User-Agent": this.config.UserAgent.value,
-            "Authorization": "Basic " + EnvironmentAdapter2.base64Encode(clientId + ":" + clientSecret)
+            "Authorization": "Basic " + CryptoUtils2.base64Encode(clientId + ":" + clientSecret)
           };
           const payload = {
             "grant_type": "refresh_token",
@@ -10040,8 +9037,8 @@ OPTIONS(description="${this.description}")`;
             muteHttpExceptions: true
           };
           try {
-            const response = EnvironmentAdapter2.fetch(url, options);
-            const result = response.getContentText();
+            const response = await HttpUtils2.fetch(url, options);
+            const result = await response.getContentText();
             const json = JSON.parse(result);
             if (json.error) {
               return { success: false, message: json.error };
@@ -10426,7 +9423,7 @@ OPTIONS(description="${this.description}")`;
         }
       };
       var RedditAdsConnector = class RedditAdsConnector extends AbstractConnector2 {
-        constructor(config, source, storageName = "GoogleSheetsStorage", runConfig = null) {
+        constructor(config, source, storageName = "GoogleBigQueryStorage", runConfig = null) {
           super(config, source, null, runConfig);
           this.storageName = storageName;
         }
@@ -10434,12 +9431,12 @@ OPTIONS(description="${this.description}")`;
          * Main method - entry point for the import process
          * Processes all nodes defined in the fields configuration
          */
-        startImportProcess() {
+        async startImportProcess() {
           const fields = RedditAdsHelper.parseFields(this.config.Fields.value);
           const accountIds = RedditAdsHelper.parseAccountIds(this.config.AccountIDs.value);
           for (const accountId of accountIds) {
             for (const nodeName in fields) {
-              this.processNode({
+              await this.processNode({
                 nodeName,
                 accountId,
                 fields: fields[nodeName] || []
@@ -10454,15 +9451,15 @@ OPTIONS(description="${this.description}")`;
          * @param {string} options.accountId - Account ID
          * @param {Array<string>} options.fields - Array of fields to fetch
          */
-        processNode({ nodeName, accountId, fields }) {
+        async processNode({ nodeName, accountId, fields }) {
           if (this.source.fieldsSchema[nodeName].isTimeSeries) {
-            this.processTimeSeriesNode({
+            await this.processTimeSeriesNode({
               nodeName,
               accountId,
               fields
             });
           } else {
-            this.processCatalogNode({
+            await this.processCatalogNode({
               nodeName,
               accountId,
               fields
@@ -10477,7 +9474,7 @@ OPTIONS(description="${this.description}")`;
          * @param {Array<string>} options.fields - Array of fields to fetch
          * @param {Object} options.storage - Storage instance
          */
-        processTimeSeriesNode({ nodeName, accountId, fields }) {
+        async processTimeSeriesNode({ nodeName, accountId, fields }) {
           var _a;
           const [startDate, daysToFetch] = this.getStartDateAndDaysToFetch();
           if (daysToFetch <= 0) {
@@ -10487,13 +9484,14 @@ OPTIONS(description="${this.description}")`;
           for (let i = 0; i < daysToFetch; i++) {
             const currentDate = new Date(startDate);
             currentDate.setDate(currentDate.getDate() + i);
-            const formattedDate = EnvironmentAdapter2.formatDate(currentDate, "UTC", "yyyy-MM-dd");
+            const formattedDate = DateUtils2.formatDate(currentDate);
             this.config.logMessage(`Start importing data for ${formattedDate}: ${accountId}/${nodeName}`);
-            const data = this.source.fetchData(nodeName, accountId, fields, currentDate);
+            const data = await this.source.fetchData(nodeName, accountId, fields, currentDate);
             this.config.logMessage(data.length ? `${data.length} records were fetched` : `No records have been fetched`);
             if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
               const preparedData = data.length ? this.addMissingFieldsToData(data, fields) : data;
-              this.getStorageByNode(nodeName).saveData(preparedData);
+              const storage = await this.getStorageByNode(nodeName);
+              await storage.saveData(preparedData);
             }
             if (this.runConfig.type === RUN_CONFIG_TYPE2.INCREMENTAL) {
               this.config.updateLastRequstedDate(currentDate);
@@ -10508,13 +9506,14 @@ OPTIONS(description="${this.description}")`;
          * @param {Array<string>} options.fields - Array of fields to fetch
          * @param {Object} options.storage - Storage instance
          */
-        processCatalogNode({ nodeName, accountId, fields }) {
+        async processCatalogNode({ nodeName, accountId, fields }) {
           var _a;
-          const data = this.source.fetchData(nodeName, accountId, fields);
+          const data = await this.source.fetchData(nodeName, accountId, fields);
           this.config.logMessage(data.length ? `${data.length} rows of ${nodeName} were fetched for account ${accountId}` : `No records have been fetched`);
           if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
             const preparedData = data.length ? this.addMissingFieldsToData(data, fields) : data;
-            this.getStorageByNode(nodeName).saveData(preparedData);
+            const storage = await this.getStorageByNode(nodeName);
+            await storage.saveData(preparedData);
           }
         }
         /**
@@ -10522,7 +9521,7 @@ OPTIONS(description="${this.description}")`;
          * @param {string} nodeName - Name of the node
          * @returns {Object} Storage instance
          */
-        getStorageByNode(nodeName) {
+        async getStorageByNode(nodeName) {
           if (!("storages" in this)) {
             this.storages = {};
           }
@@ -10540,6 +9539,7 @@ OPTIONS(description="${this.description}")`;
               this.source.fieldsSchema[nodeName].fields,
               `${this.source.fieldsSchema[nodeName].description} ${this.source.fieldsSchema[nodeName].documentation}`
             );
+            await this.storages[nodeName].init();
           }
           return this.storages[nodeName];
         }
@@ -10556,7 +9556,7 @@ OPTIONS(description="${this.description}")`;
       };
     })();
     const OpenHolidays = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
+      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils2, FileUtils: FileUtils2, DateUtils: DateUtils2, CryptoUtils: CryptoUtils2, AsyncUtils: AsyncUtils2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
       var publicHolidaysFields = {
         id: {
           type: "string",
@@ -10664,10 +9664,10 @@ OPTIONS(description="${this.description}")`;
          * @param {string} [opts.end_time]
          * @returns {Array<Object>}
          */
-        fetchData({ nodeName, fields = [], start_time, end_time }) {
+        async fetchData({ nodeName, fields = [], start_time, end_time }) {
           switch (nodeName) {
             case "publicHolidays":
-              return this._fetchPublicHolidays({ fields, start_time, end_time });
+              return await this._fetchPublicHolidays({ fields, start_time, end_time });
             default:
               throw new Error(`Unknown node: ${nodeName}`);
           }
@@ -10680,10 +9680,10 @@ OPTIONS(description="${this.description}")`;
          * @param {string} options.end_time - End date for data fetch (YYYY-MM-DD format)
          * @returns {Array} Array of holiday data
          */
-        _fetchPublicHolidays({ fields, start_time, end_time }) {
+        async _fetchPublicHolidays({ fields, start_time, end_time }) {
           let countryIsoCode = this.config.countryIsoCode.value;
           let languageIsoCode = this.config.languageIsoCode.value;
-          const holidays = this.makeRequest({
+          const holidays = await this.makeRequest({
             endpoint: `PublicHolidays?countryIsoCode=${countryIsoCode}&languageIsoCode=${languageIsoCode}&validFrom=${start_time}&validTo=${end_time}`
           });
           if (!holidays || !holidays.length) {
@@ -10710,12 +9710,13 @@ OPTIONS(description="${this.description}")`;
          * @param {string} options.endpoint - API endpoint path (e.g., "PublicHolidays?countryIsoCode=CH&...")
          * @returns {Object} - API response parsed from JSON
          */
-        makeRequest({ endpoint }) {
+        async makeRequest({ endpoint }) {
           const baseUrl = "https://openholidaysapi.org/";
           const url = `${baseUrl}${endpoint}`;
           console.log(`OpenHolidays API Request URL:`, url);
-          const response = EnvironmentAdapter2.fetch(url, { "method": "get", "muteHttpExceptions": true });
-          const result = JSON.parse(response.getContentText());
+          const response = await HttpUtils2.fetch(url, { "method": "get", "muteHttpExceptions": true });
+          const text = await response.getContentText();
+          const result = JSON.parse(text);
           return result;
         }
         /**
@@ -10741,7 +9742,7 @@ OPTIONS(description="${this.description}")`;
         }
       };
       var OpenHolidaysConnector = class OpenHolidaysConnector extends AbstractConnector2 {
-        constructor(config, source, storageName = "GoogleSheetsStorage", runConfig = null) {
+        constructor(config, source, storageName = "GoogleBigQueryStorage", runConfig = null) {
           super(config, source, null, runConfig);
           this.storageName = storageName;
         }
@@ -10749,10 +9750,10 @@ OPTIONS(description="${this.description}")`;
          * Main method - entry point for the import process
          * Processes all nodes defined in the fields configuration
          */
-        startImportProcess() {
+        async startImportProcess() {
           const fields = ConnectorUtils.parseFields(this.config.Fields.value);
           for (const nodeName in fields) {
-            this.processNode({
+            await this.processNode({
               nodeName,
               fields: fields[nodeName] || []
             });
@@ -10764,12 +9765,12 @@ OPTIONS(description="${this.description}")`;
          * @param {string} options.nodeName - Name of the node to process
          * @param {Array<string>} options.fields - Array of fields to fetch
          */
-        processNode({ nodeName, fields }) {
+        async processNode({ nodeName, fields }) {
           const storage = this.getStorageByNode(nodeName);
           if (ConnectorUtils.isTimeSeriesNode(this.source.fieldsSchema[nodeName])) {
-            this.processTimeSeriesNode({ nodeName, fields, storage });
+            await this.processTimeSeriesNode({ nodeName, fields, storage });
           } else {
-            this.processCatalogNode({ nodeName, fields, storage });
+            await this.processCatalogNode({ nodeName, fields, storage });
           }
         }
         /**
@@ -10779,14 +9780,14 @@ OPTIONS(description="${this.description}")`;
          * @param {Array<string>} options.fields - Array of fields to fetch
          * @param {Object} options.storage - Storage instance
          */
-        processTimeSeriesNode({ nodeName, fields, storage }) {
+        async processTimeSeriesNode({ nodeName, fields, storage }) {
           var _a;
           const dateRange = this.prepareDateRange();
           if (!dateRange) {
             console.log("No date range available for time series data");
             return;
           }
-          const data = this.source.fetchData({
+          const data = await this.source.fetchData({
             nodeName,
             start_time: dateRange.startDate,
             end_time: dateRange.endDate,
@@ -10795,7 +9796,7 @@ OPTIONS(description="${this.description}")`;
           this.config.logMessage(data.length ? `${data.length} rows of ${nodeName} were fetched from ${dateRange.startDate} to ${dateRange.endDate}` : `No records have been fetched`);
           if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
             const preparedData = data.length ? this.addMissingFieldsToData(data, fields) : data;
-            storage.saveData(preparedData);
+            await storage.saveData(preparedData);
           }
           if (this.runConfig.type === RUN_CONFIG_TYPE2.INCREMENTAL) {
             this.config.updateLastRequstedDate(new Date(dateRange.endDate));
@@ -10808,7 +9809,7 @@ OPTIONS(description="${this.description}")`;
          * @param {Array<string>} options.fields - Array of fields to fetch
          * @param {Object} options.storage - Storage instance
          */
-        processCatalogNode({ nodeName, fields, storage }) {
+        async processCatalogNode({ nodeName, fields, storage }) {
           console.log(`Catalog node processing not implemented for ${nodeName}`);
         }
         /**
@@ -10816,7 +9817,7 @@ OPTIONS(description="${this.description}")`;
          * @param {string} nodeName - Name of the node
          * @returns {Object} Storage instance
          */
-        getStorageByNode(nodeName) {
+        async getStorageByNode(nodeName) {
           if (!("storages" in this)) {
             this.storages = {};
           }
@@ -10834,6 +9835,7 @@ OPTIONS(description="${this.description}")`;
               this.source.fieldsSchema[nodeName].fields,
               `${this.source.fieldsSchema[nodeName].description} ${this.source.fieldsSchema[nodeName].documentation}`
             );
+            await this.storages[nodeName].init();
           }
           return this.storages[nodeName];
         }
@@ -10849,8 +9851,8 @@ OPTIONS(description="${this.description}")`;
           const endDate = new Date(startDate);
           endDate.setDate(endDate.getDate() + daysToFetch - 1);
           return {
-            startDate: EnvironmentAdapter2.formatDate(startDate, "UTC", "yyyy-MM-dd"),
-            endDate: EnvironmentAdapter2.formatDate(endDate, "UTC", "yyyy-MM-dd")
+            startDate: DateUtils2.formatDate(startDate),
+            endDate: DateUtils2.formatDate(endDate)
           };
         }
       };
@@ -10866,7 +9868,7 @@ OPTIONS(description="${this.description}")`;
       };
     })();
     const OpenExchangeRates = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
+      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils2, FileUtils: FileUtils2, DateUtils: DateUtils2, CryptoUtils: CryptoUtils2, AsyncUtils: AsyncUtils2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
       var historicalFields = {
         date: {
           type: "DATE",
@@ -10954,12 +9956,12 @@ OPTIONS(description="${this.description}")`;
           this.fieldsSchema = OpenExchangeRatesFieldsSchema;
         }
         /*
-        @param date The requested date as a Date object
+          @param date The requested date as a Date object
         
-        @return data array
+          @return data array
         
-        */
-        fetchData(date) {
+          */
+        async fetchData(date) {
           let data = [];
           let base = this.config.base.value;
           let app_id = this.config.AppId.value;
@@ -10967,13 +9969,14 @@ OPTIONS(description="${this.description}")`;
           if (this.config.Symbols.value) {
             symbols = "&symbols=" + String(this.config.Symbols.value).replace(/[^A-Z,]/g, "");
           }
-          var date = EnvironmentAdapter2.formatDate(date, "UTC", "yyyy-MM-dd");
+          var date = DateUtils2.formatDate(date);
           const urlWithoutKey = `https://openexchangerates.org/api/historical/${date}.json?base=${base}${symbols}`;
           console.log(`OpenExchangeRates API URL:`, urlWithoutKey);
           const url = `${urlWithoutKey}&app_id=${app_id}`;
           this.config.logMessage(`Fetching rates for ${date}`);
-          var response = EnvironmentAdapter2.fetch(url, { "method": "get", "muteHttpExceptions": true });
-          var historical = JSON.parse(response.getContentText());
+          var response = await HttpUtils2.fetch(url, { "method": "get", "muteHttpExceptions": true });
+          var text = await response.getContentText();
+          var historical = JSON.parse(text);
           for (var currency in historical["rates"]) {
             data.push({
               date: new Date(date),
@@ -10986,7 +9989,7 @@ OPTIONS(description="${this.description}")`;
         }
       };
       var OpenExchangeRatesConnector = class OpenExchangeRatesConnector extends AbstractConnector2 {
-        constructor(config, source, storageName = "GoogleSheetsStorage", runConfig = null) {
+        constructor(config, source, storageName = "GoogleBigQueryStorage", runConfig = null) {
           super(config, source, null, runConfig);
           this.storageName = storageName;
         }
@@ -10999,11 +10002,11 @@ OPTIONS(description="${this.description}")`;
          * Main method - entry point for the import process
          * Processes all nodes defined in the fields configuration
          */
-        startImportProcess() {
+        async startImportProcess() {
           var _a;
           const fields = ConnectorUtils.parseFields((_a = this.config.Fields) == null ? void 0 : _a.value);
           for (const nodeName in fields) {
-            this.processNode({
+            await this.processNode({
               nodeName,
               fields: fields[nodeName] || []
             });
@@ -11015,11 +10018,11 @@ OPTIONS(description="${this.description}")`;
          * @param {string} options.nodeName - Name of the node to process
          * @param {Array<string>} options.fields - Array of fields to fetch
          */
-        processNode({ nodeName, fields }) {
+        async processNode({ nodeName, fields }) {
           if (this.source.fieldsSchema[nodeName].isTimeSeries) {
-            this.processTimeSeriesNode({ nodeName, fields });
+            await this.processTimeSeriesNode({ nodeName, fields });
           } else {
-            this.processCatalogNode({ nodeName, fields });
+            await this.processCatalogNode({ nodeName, fields });
           }
         }
         /**
@@ -11028,7 +10031,7 @@ OPTIONS(description="${this.description}")`;
          * @param {string} options.nodeName - Name of the node
          * @param {Array<string>} options.fields - Array of fields to fetch
          */
-        processTimeSeriesNode({ nodeName, fields }) {
+        async processTimeSeriesNode({ nodeName, fields }) {
           var _a;
           const [startDate, daysToFetch] = this.getStartDateAndDaysToFetch();
           if (daysToFetch <= 0) {
@@ -11038,11 +10041,12 @@ OPTIONS(description="${this.description}")`;
           for (let daysShift = 0; daysShift < daysToFetch; daysShift++) {
             const currentDate = new Date(startDate);
             currentDate.setDate(currentDate.getDate() + daysShift);
-            let data = this.source.fetchData(currentDate);
+            let data = await this.source.fetchData(currentDate);
             this.config.logMessage(data.length ? `${data.length} rows were fetched` : `No records have been fetched`);
             if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
               const preparedData = data.length ? data : [];
-              this.getStorageByNode(nodeName).saveData(preparedData);
+              const storage = await this.getStorageByNode(nodeName);
+              await storage.saveData(preparedData);
             }
             if (this.runConfig.type === RUN_CONFIG_TYPE2.INCREMENTAL) {
               this.config.updateLastRequstedDate(currentDate);
@@ -11055,7 +10059,7 @@ OPTIONS(description="${this.description}")`;
          * @param {string} options.nodeName - Name of the node
          * @param {Array<string>} options.fields - Array of fields to fetch
          */
-        processCatalogNode({ nodeName, fields }) {
+        async processCatalogNode({ nodeName, fields }) {
           console.log(`Catalog node processing not implemented for ${nodeName}`);
         }
         //---- getStorageName -------------------------------------------------
@@ -11067,7 +10071,7 @@ OPTIONS(description="${this.description}")`;
          * @return AbstractStorage 
          * 
          */
-        getStorageByNode(nodeName) {
+        async getStorageByNode(nodeName) {
           if (!("storages" in this)) {
             this.storages = {};
           }
@@ -11085,6 +10089,7 @@ OPTIONS(description="${this.description}")`;
               this.source.fieldsSchema[nodeName]["fields"],
               `${this.source.fieldsSchema[nodeName]["description"]} ${this.source.fieldsSchema[nodeName]["documentation"]}`
             );
+            await this.storages[nodeName].init();
           }
           return this.storages[nodeName];
         }
@@ -11101,7 +10106,7 @@ OPTIONS(description="${this.description}")`;
       };
     })();
     const MicrosoftAds = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
+      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils2, FileUtils: FileUtils2, DateUtils: DateUtils2, CryptoUtils: CryptoUtils2, AsyncUtils: AsyncUtils2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
       const MicrosoftAdsHelper = {
         /**
          * Parse fields string into a structured object
@@ -11124,7 +10129,7 @@ OPTIONS(description="${this.description}")`;
          * @param {number} [opts.interval=5000]
          * @returns {Object}
          */
-        pollUntilStatus({ url, options, isDone, interval = 5e3 }) {
+        async pollUntilStatus({ url, options, isDone, interval = 5e3 }) {
           const startTime = Date.now();
           const timeout = 15 * 60 * 1e3;
           let statusResult;
@@ -11133,9 +10138,10 @@ OPTIONS(description="${this.description}")`;
               if (Date.now() - startTime > timeout) {
                 throw new Error("Polling timed out after 15 minutes");
               }
-              EnvironmentAdapter2.sleep(interval);
-              const response = EnvironmentAdapter2.fetch(url, options);
-              statusResult = JSON.parse(response.getContentText());
+              await AsyncUtils2.delay(interval);
+              const response = await HttpUtils2.fetch(url, options);
+              const text = await response.getContentText();
+              statusResult = JSON.parse(text);
             } while (!isDone(statusResult));
             return statusResult;
           } catch (error) {
@@ -11151,13 +10157,14 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} url
          * @returns {Array<Array<string>>}
          */
-        downloadCsvRows(url) {
-          const response = EnvironmentAdapter2.fetch(url);
-          const files = EnvironmentAdapter2.unzip(response.getBlob());
+        async downloadCsvRows(url) {
+          const response = await HttpUtils2.fetch(url);
+          const blob = await response.getBlob();
+          const files = FileUtils2.unzip(blob);
           const allRows = [];
           files.forEach((file) => {
             const csvText = file.getDataAsString();
-            const rows = EnvironmentAdapter2.parseCsv(csvText);
+            const rows = FileUtils2.parseCsv(csvText);
             allRows.push(...rows);
           });
           return allRows;
@@ -12284,7 +11291,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
         /**
          * Retrieve and store an OAuth access token using the refresh token
          */
-        getAccessToken() {
+        async getAccessToken() {
           var _a, _b;
           const tokenUrl = "https://login.microsoftonline.com/common/oauth2/v2.0/token";
           const scopes = [
@@ -12310,8 +11317,9 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
                 body: Object.entries(form).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&")
                 // TODO: body is for Node.js; refactor to centralize JSON option creation
               };
-              const resp = EnvironmentAdapter2.fetch(tokenUrl, options);
-              const json = JSON.parse(resp.getContentText());
+              const resp = await HttpUtils2.fetch(tokenUrl, options);
+              const text = await resp.getContentText();
+              const json = JSON.parse(text);
               if (json.error) {
                 throw new Error(`Token error: ${json.error} - ${json.error_description}`);
               }
@@ -12337,7 +11345,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Function} [opts.onBatchReady] - Optional callback for batch processing
          * @returns {Array<Object>}
          */
-        fetchData({ nodeName, accountId, fields = [], start_time, end_time, onBatchReady }) {
+        async fetchData({ nodeName, accountId, fields = [], start_time, end_time, onBatchReady }) {
           const schema = this.fieldsSchema[nodeName];
           if (schema.uniqueKeys) {
             const missingKeys = schema.uniqueKeys.filter((key) => !fields.includes(key));
@@ -12347,12 +11355,12 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
           }
           switch (nodeName) {
             case "campaigns":
-              this._fetchCampaignData({ accountId, fields, onBatchReady });
+              await this._fetchCampaignData({ accountId, fields, onBatchReady });
               return [];
             case "ad_performance_report":
-              return this._fetchReportData({ accountId, fields, start_time, end_time, nodeName });
+              return await this._fetchReportData({ accountId, fields, start_time, end_time, nodeName });
             case "user_location_performance_report":
-              return this._fetchReportData({ accountId, fields, start_time, end_time, nodeName });
+              return await this._fetchReportData({ accountId, fields, start_time, end_time, nodeName });
             default:
               throw new Error(`Unknown node: ${nodeName}`);
           }
@@ -12366,14 +11374,14 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @returns {void}
          * @private
          */
-        _fetchCampaignData({ accountId, fields, onBatchReady }) {
-          this.getAccessToken();
+        async _fetchCampaignData({ accountId, fields, onBatchReady }) {
+          await this.getAccessToken();
           this.config.logMessage(`Fetching Campaigns, AssetGroups and AdGroups for account ${accountId}...`);
           const entityTypes = ["Campaigns", "AssetGroups", "AdGroups"];
           const allRecords = [];
           let campaignRecords = [];
           for (const entityType of entityTypes) {
-            const records = this._downloadEntity({
+            const records = await this._downloadEntity({
               submitUrl: "https://bulk.api.bingads.microsoft.com/Bulk/v13/Campaigns/DownloadByAccountIds",
               submitOpts: {
                 method: "post",
@@ -12411,21 +11419,21 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
           }
           const filteredMainData = MicrosoftAdsHelper.filterByFields(allRecords, fields);
           if (filteredMainData.length > 0) {
-            onBatchReady(filteredMainData);
+            await onBatchReady(filteredMainData);
           }
           this.config.logMessage(`Fetching Keywords for account ${accountId} (processing by campaigns to avoid size limits)...`);
           const campaignIds = MicrosoftAdsHelper.extractCampaignIds(campaignRecords);
           this.config.logMessage(`Found ${campaignIds.length} campaigns, fetching Keywords in batches`);
           this.config.logMessage(`Campaign IDs: ${campaignIds.slice(0, 10).join(", ")}${campaignIds.length > 10 ? "..." : ""}`);
           let totalFetched = 0;
-          this._fetchEntityByCampaigns({
+          await this._fetchEntityByCampaigns({
             accountId,
             entityType: "Keywords",
             campaignIds,
-            onBatchReady: (batchRecords) => {
+            onBatchReady: async (batchRecords) => {
               totalFetched += batchRecords.length;
               const filteredBatch = MicrosoftAdsHelper.filterByFields(batchRecords, fields);
-              onBatchReady(filteredBatch);
+              await onBatchReady(filteredBatch);
             }
           });
           this.config.logMessage(`${totalFetched} rows of Keywords were fetched for account ${accountId}`);
@@ -12439,15 +11447,16 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @returns {Array<Object>}
          * @private
          */
-        _downloadEntity({ submitUrl, submitOpts }) {
-          const submitResp = EnvironmentAdapter2.fetch(submitUrl, submitOpts);
-          const requestId = JSON.parse(submitResp.getContentText()).DownloadRequestId;
+        async _downloadEntity({ submitUrl, submitOpts }) {
+          const submitResp = await HttpUtils2.fetch(submitUrl, submitOpts);
+          const text = await submitResp.getContentText();
+          const requestId = JSON.parse(text).DownloadRequestId;
           const pollUrl = "https://bulk.api.bingads.microsoft.com/Bulk/v13/BulkDownloadStatus/Query";
           const pollOpts = Object.assign({}, submitOpts, {
             payload: JSON.stringify({ RequestId: requestId }),
             body: JSON.stringify({ RequestId: requestId })
           });
-          const pollResult = MicrosoftAdsHelper.pollUntilStatus({
+          const pollResult = await MicrosoftAdsHelper.pollUntilStatus({
             url: pollUrl,
             options: pollOpts,
             isDone: (status) => {
@@ -12457,7 +11466,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
               return status.RequestStatus === "Completed";
             }
           });
-          const csvRows = MicrosoftAdsHelper.downloadCsvRows(pollResult.ResultFileUrl);
+          const csvRows = await MicrosoftAdsHelper.downloadCsvRows(pollResult.ResultFileUrl);
           const result = MicrosoftAdsHelper.csvRowsToObjects(csvRows);
           return result;
         }
@@ -12471,7 +11480,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @returns {Array<Object>} - Returns empty array if onBatchReady callback is provided, otherwise returns all records
          * @private
          */
-        _fetchEntityByCampaigns({ accountId, entityType, campaignIds, onBatchReady }) {
+        async _fetchEntityByCampaigns({ accountId, entityType, campaignIds, onBatchReady }) {
           if (campaignIds.length === 0) {
             this.config.logMessage(`No active campaigns found for account ${accountId}, skipping ${entityType} fetch`);
             return [];
@@ -12481,9 +11490,9 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             const campaignBatch = campaignIds.slice(i, i + batchSize);
             this.config.logMessage(`Fetching ${entityType} for campaigns batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(campaignIds.length / batchSize)} (${campaignBatch.length} campaigns)`);
             try {
-              const batchRecords = this._downloadEntityBatch({ accountId, entityType, campaignBatch });
+              const batchRecords = await this._downloadEntityBatch({ accountId, entityType, campaignBatch });
               this.config.logMessage(`Fetched ${batchRecords.length} ${entityType.toLowerCase()} from current batch`);
-              onBatchReady(batchRecords);
+              await onBatchReady(batchRecords);
             } catch (error) {
               if (error.message && error.message.includes("100MB")) {
                 const newBatchSize = Math.max(1, Math.floor(batchSize / 2));
@@ -12491,9 +11500,9 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
                 for (let j = i; j < Math.min(i + batchSize, campaignIds.length); j += newBatchSize) {
                   const smallerBatch = campaignIds.slice(j, j + newBatchSize);
                   try {
-                    const smallerBatchRecords = this._downloadEntityBatch({ accountId, entityType, campaignBatch: smallerBatch });
+                    const smallerBatchRecords = await this._downloadEntityBatch({ accountId, entityType, campaignBatch: smallerBatch });
                     this.config.logMessage(`Fetched ${smallerBatchRecords.length} ${entityType.toLowerCase()} from smaller batch (${smallerBatch.length} campaigns)`);
-                    onBatchReady(smallerBatchRecords);
+                    await onBatchReady(smallerBatchRecords);
                   } catch (smallerError) {
                     if (smallerError.message && smallerError.message.includes("100MB")) {
                       throw new Error(`Failed to fetch ${entityType}: batch size of ${smallerBatch.length} campaigns still exceeds 100MB limit`);
@@ -12520,7 +11529,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @returns {Array<Object>}
          * @private
          */
-        _downloadEntityBatch({ accountId, entityType, campaignBatch }) {
+        async _downloadEntityBatch({ accountId, entityType, campaignBatch }) {
           const downloadBody = {
             Campaigns: campaignBatch.map((id) => ({
               CampaignId: Number(id),
@@ -12545,7 +11554,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             payload: JSON.stringify(downloadBody),
             body: JSON.stringify(downloadBody)
           };
-          return this._downloadEntity({
+          return await this._downloadEntity({
             submitUrl: "https://bulk.api.bingads.microsoft.com/Bulk/v13/Campaigns/DownloadByCampaignIds",
             submitOpts
           });
@@ -12561,22 +11570,22 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @returns {Array<Object>}
          * @private
          */
-        _fetchReportData({ accountId, fields, start_time, end_time, nodeName }) {
-          this.getAccessToken();
+        async _fetchReportData({ accountId, fields, start_time, end_time, nodeName }) {
+          await this.getAccessToken();
           const schema = this.fieldsSchema[nodeName];
-          const submitResponse = this._submitReportRequest({
+          const submitResponse = await this._submitReportRequest({
             accountId,
             fields,
             start_time,
             end_time,
             schema
           });
-          const pollResult = this._pollReportStatus({ submitResponse });
+          const pollResult = await this._pollReportStatus({ submitResponse });
           if (!pollResult.ReportRequestStatus.ReportDownloadUrl) {
             this.config.logMessage(`No data available for the specified time period (${start_time} to ${end_time}). Report status: ${JSON.stringify(pollResult.ReportRequestStatus)}`);
             return [];
           }
-          const csvRows = MicrosoftAdsHelper.downloadCsvRows(pollResult.ReportRequestStatus.ReportDownloadUrl);
+          const csvRows = await MicrosoftAdsHelper.downloadCsvRows(pollResult.ReportRequestStatus.ReportDownloadUrl);
           const records = MicrosoftAdsHelper.csvRowsToObjects(csvRows);
           return MicrosoftAdsHelper.filterByFields(records, fields);
         }
@@ -12591,7 +11600,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @returns {Object} - Submit response
          * @private
          */
-        _submitReportRequest({ accountId, fields, start_time, end_time, schema }) {
+        async _submitReportRequest({ accountId, fields, start_time, end_time, schema }) {
           const dateRange = {
             CustomDateRangeStart: { Day: new Date(start_time).getDate(), Month: new Date(start_time).getMonth() + 1, Year: new Date(start_time).getFullYear() },
             CustomDateRangeEnd: { Day: new Date(end_time).getDate(), Month: new Date(end_time).getMonth() + 1, Year: new Date(end_time).getFullYear() },
@@ -12624,8 +11633,8 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             body: JSON.stringify({ ReportRequest: requestBody })
             // TODO: body is for Node.js; refactor to centralize JSON option creation
           };
-          const submitResp = EnvironmentAdapter2.fetch(submitUrl, submitOpts);
-          const submitResponseText = submitResp.getContentText();
+          const submitResp = await HttpUtils2.fetch(submitUrl, submitOpts);
+          const submitResponseText = await submitResp.getContentText();
           try {
             const submitResponse = JSON.parse(submitResponseText);
             if (submitResponse.OperationErrors && submitResponse.OperationErrors.length > 0) {
@@ -12649,7 +11658,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @returns {Object} - Poll result with report status
          * @private
          */
-        _pollReportStatus({ submitResponse }) {
+        async _pollReportStatus({ submitResponse }) {
           const pollUrl = "https://reporting.api.bingads.microsoft.com/Reporting/v13/GenerateReport/Poll";
           const submitResponseText = JSON.stringify(submitResponse);
           const pollOpts = {
@@ -12665,7 +11674,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             payload: submitResponseText,
             body: submitResponseText
           };
-          return MicrosoftAdsHelper.pollUntilStatus({
+          return await MicrosoftAdsHelper.pollUntilStatus({
             url: pollUrl,
             options: pollOpts,
             isDone: (status) => {
@@ -12678,7 +11687,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
         }
       };
       var MicrosoftAdsConnector = class MicrosoftAdsConnector extends AbstractConnector2 {
-        constructor(config, source, storageName = "GoogleSheetsStorage", runConfig = null) {
+        constructor(config, source, storageName = "GoogleBigQueryStorage", runConfig = null) {
           super(config, source, null, runConfig);
           this.storageName = storageName;
         }
@@ -12686,10 +11695,10 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * Main method - entry point for the import process
          * Processes all nodes defined in the fields configuration
          */
-        startImportProcess() {
+        async startImportProcess() {
           const fields = MicrosoftAdsHelper.parseFields(this.config.Fields.value);
           for (const nodeName in fields) {
-            this.processNode({
+            await this.processNode({
               nodeName,
               accountId: this.config.AccountID.value,
               fields: fields[nodeName] || []
@@ -12703,15 +11712,15 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} options.accountId - Account ID
          * @param {Array<string>} options.fields - Array of fields to fetch
          */
-        processNode({ nodeName, accountId, fields }) {
+        async processNode({ nodeName, accountId, fields }) {
           if (this.source.fieldsSchema[nodeName].isTimeSeries) {
-            this.processTimeSeriesNode({
+            await this.processTimeSeriesNode({
               nodeName,
               accountId,
               fields
             });
           } else {
-            this.processCatalogNode({
+            await this.processCatalogNode({
               nodeName,
               accountId,
               fields
@@ -12726,7 +11735,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Array<string>} options.fields - Array of fields to fetch
          * @param {Object} options.storage - Storage instance
          */
-        processTimeSeriesNode({ nodeName, accountId, fields }) {
+        async processTimeSeriesNode({ nodeName, accountId, fields }) {
           var _a;
           const [startDate, daysToFetch] = this.getStartDateAndDaysToFetch();
           if (daysToFetch <= 0) {
@@ -12736,9 +11745,9 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
           for (let dayOffset = 0; dayOffset < daysToFetch; dayOffset++) {
             const currentDate = new Date(startDate);
             currentDate.setDate(currentDate.getDate() + dayOffset);
-            const formattedDate = EnvironmentAdapter2.formatDate(currentDate, "UTC", "yyyy-MM-dd");
+            const formattedDate = DateUtils2.formatDate(currentDate);
             this.config.logMessage(`Processing ${nodeName} for ${accountId} on ${formattedDate} (day ${dayOffset + 1} of ${daysToFetch})`);
-            const data = this.source.fetchData({
+            const data = await this.source.fetchData({
               nodeName,
               accountId,
               start_time: formattedDate,
@@ -12748,7 +11757,8 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             this.config.logMessage(data.length ? `${data.length} rows of ${nodeName} were fetched for ${accountId} on ${formattedDate}` : `No records have been fetched`);
             if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
               const preparedData = data.length ? this.addMissingFieldsToData(data, fields) : data;
-              this.getStorageByNode(nodeName).saveData(preparedData);
+              const storage = await this.getStorageByNode(nodeName);
+              await storage.saveData(preparedData);
               data.length && this.config.logMessage(`Successfully saved ${data.length} rows for ${formattedDate}`);
             }
             if (this.runConfig.type === RUN_CONFIG_TYPE2.INCREMENTAL) {
@@ -12764,22 +11774,24 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Array<string>} options.fields - Array of fields to fetch
          * @param {Object} options.storage - Storage instance
          */
-        processCatalogNode({ nodeName, accountId, fields }) {
+        async processCatalogNode({ nodeName, accountId, fields }) {
           var _a;
-          const data = this.source.fetchData({
+          const data = await this.source.fetchData({
             nodeName,
             accountId,
             fields,
-            onBatchReady: (batchData) => {
+            onBatchReady: async (batchData) => {
               this.config.logMessage(`Saving batch of ${batchData.length} records to storage`);
               const preparedData = this.addMissingFieldsToData(batchData, fields);
-              this.getStorageByNode(nodeName).saveData(preparedData);
+              const storage = await this.getStorageByNode(nodeName);
+              await storage.saveData(preparedData);
             }
           });
           this.config.logMessage(data.length ? `${data.length} rows of ${nodeName} were fetched for ${accountId}` : `No records have been fetched`);
           if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
             const preparedData = data.length ? this.addMissingFieldsToData(data, fields) : data;
-            this.getStorageByNode(nodeName).saveData(preparedData);
+            const storage = await this.getStorageByNode(nodeName);
+            await storage.saveData(preparedData);
           }
         }
         /**
@@ -12787,7 +11799,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} nodeName - Name of the node
          * @returns {Object} Storage instance
          */
-        getStorageByNode(nodeName) {
+        async getStorageByNode(nodeName) {
           if (!("storages" in this)) {
             this.storages = {};
           }
@@ -12805,6 +11817,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
               this.source.fieldsSchema[nodeName].fields,
               `${this.source.fieldsSchema[nodeName].description} ${this.source.fieldsSchema[nodeName].documentation}`
             );
+            await this.storages[nodeName].init();
           }
           return this.storages[nodeName];
         }
@@ -12821,7 +11834,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
       };
     })();
     const LinkedInPages = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
+      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils2, FileUtils: FileUtils2, DateUtils: DateUtils2, CryptoUtils: CryptoUtils2, AsyncUtils: AsyncUtils2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
       var followerStatisticsTimeBoundFields = {
         "organization_urn": {
           "description": "Organization URN",
@@ -13003,7 +12016,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Object} params - Additional parameters for the request
          * @returns {Array} - Array of processed data objects
          */
-        fetchData(nodeName, urn, params = {}) {
+        async fetchData(nodeName, urn, params = {}) {
           var _a;
           const fields = params.fields || [];
           const uniqueKeys = ((_a = this.fieldsSchema[nodeName]) == null ? void 0 : _a.uniqueKeys) || [];
@@ -13013,7 +12026,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
           }
           switch (nodeName) {
             case "follower_statistics_time_bound":
-              return this.fetchOrganizationStats({
+              return await this.fetchOrganizationStats({
                 urn,
                 nodeName,
                 endpoint: "organizationalEntityFollowerStatistics",
@@ -13022,7 +12035,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
                 params
               });
             case "follower_statistics":
-              return this.fetchOrganizationStats({
+              return await this.fetchOrganizationStats({
                 urn,
                 nodeName,
                 endpoint: "organizationalEntityFollowerStatistics",
@@ -13047,7 +12060,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Array} [options.params.fields] - Additional parameters including fields
          * @returns {Array} - Processed statistics data
          */
-        fetchOrganizationStats(options) {
+        async fetchOrganizationStats(options) {
           const { urn, nodeName, endpoint, entityParam, formatter, params } = options;
           const orgUrn = `urn:li:organization:${urn}`;
           const encodedUrn = encodeURIComponent(orgUrn);
@@ -13058,7 +12071,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             const endTimestamp = new Date(params.endDate).getTime();
             url += `&timeIntervals=(timeRange:(start:${startTimestamp},end:${endTimestamp}),timeGranularityType:DAY)`;
           }
-          const response = this.makeRequest(url);
+          const response = await this.makeRequest(url);
           const elements = response.elements || [];
           if (elements.length === 0) {
             return [];
@@ -13075,9 +12088,9 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Object} headers - Optional additional headers
          * @returns {Object} - API response parsed from JSON
          */
-        makeRequest(url) {
+        async makeRequest(url) {
           console.log(`LinkedIn Pages API URL:`, url);
-          OAuthUtils.getAccessToken({
+          await OAuthUtils.getAccessToken({
             config: this.config,
             tokenUrl: "https://www.linkedin.com/oauth/v2/accessToken",
             formData: {
@@ -13092,12 +12105,13 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             "X-RestLi-Protocol-Version": "2.0.0"
           };
           const authUrl = `${url}${url.includes("?") ? "&" : "?"}oauth2_access_token=${this.config.AccessToken.value}`;
-          const response = EnvironmentAdapter2.fetch(authUrl, { headers });
-          const result = JSON.parse(response.getContentText());
-          if (result.status && result.status >= HTTP_STATUS2.BAD_REQUEST) {
-            throw new Error(`LinkedIn API Error: ${result.message || "Unknown error"} (Status: ${result.status})`);
+          const response = await HttpUtils2.fetch(authUrl, { headers });
+          const result = await response.getContentText();
+          const parsedResult = JSON.parse(result);
+          if (parsedResult.status && parsedResult.status >= HTTP_STATUS2.BAD_REQUEST) {
+            throw new Error(`LinkedIn API Error: ${parsedResult.message || "Unknown error"} (Status: ${parsedResult.status})`);
           }
-          return result;
+          return parsedResult;
         }
         /**
          * Process time-bound statistics data
@@ -13191,7 +12205,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
         }
       };
       var LinkedInPagesConnector = class LinkedInPagesConnector extends AbstractConnector2 {
-        constructor(config, source, storageName = "GoogleSheetsStorage", runConfig = null) {
+        constructor(config, source, storageName = "GoogleBigQueryStorage", runConfig = null) {
           super(config, source, null, runConfig);
           this.storageName = storageName;
         }
@@ -13199,11 +12213,11 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * Main method - entry point for the import process
          * Processes all nodes defined in the fields configuration
          */
-        startImportProcess() {
+        async startImportProcess() {
           const urns = FormatUtils.parseIds(this.config.OrganizationURNs.value, { prefix: "urn:li:organization:" });
           const dataSources = FormatUtils.parseFields(this.config.Fields.value);
           for (const nodeName in dataSources) {
-            this.processNode({
+            await this.processNode({
               nodeName,
               urns,
               fields: dataSources[nodeName] || []
@@ -13217,13 +12231,13 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Array} options.urns - URNs to process
          * @param {Array} options.fields - Fields to fetch
          */
-        processNode({ nodeName, urns, fields }) {
+        async processNode({ nodeName, urns, fields }) {
           const isTimeSeriesNode = ConnectorUtils.isTimeSeriesNode(this.source.fieldsSchema[nodeName]);
           const dateInfo = this.prepareDateRangeIfNeeded(nodeName, isTimeSeriesNode);
           if (isTimeSeriesNode && !dateInfo) {
             return;
           }
-          this.fetchAndSaveData({
+          await this.fetchAndSaveData({
             nodeName,
             urns,
             fields,
@@ -13244,7 +12258,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} [options.startDate] - Start date for time series data
          * @param {string} [options.endDate] - End date for time series data
          */
-        fetchAndSaveData({ nodeName, urns, fields, isTimeSeriesNode, startDate, endDate }) {
+        async fetchAndSaveData({ nodeName, urns, fields, isTimeSeriesNode, startDate, endDate }) {
           var _a;
           for (const urn of urns) {
             console.log(`Processing ${nodeName} for ${urn}${isTimeSeriesNode ? ` from ${startDate} to ${endDate}` : ""}`);
@@ -13252,11 +12266,12 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
               console.log(`End date is +1 day due to LinkedIn Pages API requirements (to include actual end date in results)`);
             }
             const params = { fields, ...isTimeSeriesNode && { startDate, endDate } };
-            const data = this.source.fetchData(nodeName, urn, params);
+            const data = await this.source.fetchData(nodeName, urn, params);
             this.config.logMessage(data.length ? `${data.length} rows of ${nodeName} were fetched for ${urn}${endDate ? ` from ${startDate} to ${endDate}` : ""}` : `No records have been fetched`);
             if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
               const preparedData = data.length ? this.addMissingFieldsToData(data, fields) : data;
-              this.getStorageByNode(nodeName).saveData(preparedData);
+              const storage = await this.getStorageByNode(nodeName);
+              await storage.saveData(preparedData);
             }
           }
         }
@@ -13265,7 +12280,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} nodeName - Name of the node
          * @returns {Object} - Storage instance
          */
-        getStorageByNode(nodeName) {
+        async getStorageByNode(nodeName) {
           if (!("storages" in this)) {
             this.storages = {};
           }
@@ -13283,6 +12298,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
               this.source.fieldsSchema[nodeName]["fields"],
               `${this.source.fieldsSchema[nodeName]["description"]} ${this.source.fieldsSchema[nodeName]["documentation"]}`
             );
+            await this.storages[nodeName].init();
           }
           return this.storages[nodeName];
         }
@@ -13320,7 +12336,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
       };
     })();
     const LinkedInAds = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
+      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils2, FileUtils: FileUtils2, DateUtils: DateUtils2, CryptoUtils: CryptoUtils2, AsyncUtils: AsyncUtils2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
       var creativesFields = {
         "account": {
           "description": "URN identifying the advertising account associated with the creative. This field is read-only.",
@@ -14276,7 +13292,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Object} params - Additional parameters for the request
          * @returns {Array} - Array of fetched data objects
          */
-        fetchData(nodeName, urn, params = {}) {
+        async fetchData(nodeName, urn, params = {}) {
           var _a;
           const fields = params.fields || [];
           const uniqueKeys = ((_a = this.fieldsSchema[nodeName]) == null ? void 0 : _a.uniqueKeys) || [];
@@ -14286,15 +13302,15 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
           }
           switch (nodeName) {
             case "adAccounts":
-              return this.fetchSingleResource({ urn, resourceType: "adAccounts", params });
+              return await this.fetchSingleResource({ urn, resourceType: "adAccounts", params });
             case "adCampaignGroups":
-              return this.fetchAdResource({ urn, resourceType: "adCampaignGroups", params });
+              return await this.fetchAdResource({ urn, resourceType: "adCampaignGroups", params });
             case "adCampaigns":
-              return this.fetchAdResource({ urn, resourceType: "adCampaigns", params });
+              return await this.fetchAdResource({ urn, resourceType: "adCampaigns", params });
             case "creatives":
-              return this.fetchAdResource({ urn, resourceType: "creatives", params, queryType: "criteria" });
+              return await this.fetchAdResource({ urn, resourceType: "creatives", params, queryType: "criteria" });
             case "adAnalytics":
-              return this.fetchAdAnalytics(urn, params);
+              return await this.fetchAdAnalytics(urn, params);
             default:
               throw new Error(`Unknown node: ${nodeName}`);
           }
@@ -14307,10 +13323,10 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Object} options.params - Additional parameters for the request
          * @returns {Array} - Array containing the single resource
          */
-        fetchSingleResource({ urn, resourceType, params }) {
+        async fetchSingleResource({ urn, resourceType, params }) {
           let url = `${this.BASE_URL}${resourceType}/${encodeURIComponent(urn)}`;
           url += `?fields=${this.formatFields(params.fields)}`;
-          const result = this.makeRequest(url);
+          const result = await this.makeRequest(url);
           return [result];
         }
         /**
@@ -14322,10 +13338,10 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} [options.queryType='search'] - Query type parameter
          * @returns {Array} - Array of fetched resources
          */
-        fetchAdResource({ urn, resourceType, params, queryType = "search" }) {
+        async fetchAdResource({ urn, resourceType, params, queryType = "search" }) {
           let url = `${this.BASE_URL}adAccounts/${encodeURIComponent(urn)}/${resourceType}?q=${queryType}&pageSize=100`;
           url += `&fields=${this.formatFields(params.fields)}`;
-          return this.fetchWithPagination(url);
+          return await this.fetchWithPagination(url);
         }
         /**
          * Fetch analytics data, handling field limits and data merging
@@ -14336,7 +13352,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Array} params.fields - Fields to fetch
          * @returns {Array} - Combined array of analytics data
          */
-        fetchAdAnalytics(urn, params) {
+        async fetchAdAnalytics(urn, params) {
           const startDate = new Date(params.startDate);
           const endDate = new Date(params.endDate);
           const accountUrn = `urn:li:sponsoredAccount:${urn}`;
@@ -14351,7 +13367,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
               encodedUrn,
               fields: fieldChunk
             });
-            const res = this.makeRequest(url);
+            const res = await this.makeRequest(url);
             const elements = res.elements || [];
             allResults = this.mergeAnalyticsResults(allResults, elements);
           }
@@ -14480,9 +13496,9 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Object} headers - Optional additional headers
          * @returns {Object} - API response parsed from JSON
          */
-        makeRequest(url) {
+        async makeRequest(url) {
           console.log(`LinkedIn Ads API Request URL:`, url);
-          OAuthUtils.getAccessToken({
+          await OAuthUtils.getAccessToken({
             config: this.config,
             tokenUrl: "https://www.linkedin.com/oauth/v2/accessToken",
             formData: {
@@ -14497,8 +13513,9 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             "X-RestLi-Protocol-Version": "2.0.0"
           };
           const authUrl = `${url}${url.includes("?") ? "&" : "?"}oauth2_access_token=${this.config.AccessToken.value}`;
-          const response = EnvironmentAdapter2.fetch(authUrl, { headers });
-          const result = JSON.parse(response.getContentText());
+          const response = await HttpUtils2.fetch(authUrl, { headers });
+          const text = await response.getContentText();
+          const result = JSON.parse(text);
           return result;
         }
         /**
@@ -14507,7 +13524,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Object} headers - Optional additional headers
          * @returns {Array} - Combined array of results from all pages
          */
-        fetchWithPagination(baseUrl) {
+        async fetchWithPagination(baseUrl) {
           let allResults = [];
           let pageToken = null;
           do {
@@ -14515,7 +13532,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             if (pageToken) {
               pageUrl += `${pageUrl.includes("?") ? "&" : "?"}pageToken=${encodeURIComponent(pageToken)}`;
             }
-            const res = this.makeRequest(pageUrl);
+            const res = await this.makeRequest(pageUrl);
             const elements = res.elements || [];
             allResults = allResults.concat(elements);
             const metadata = res.metadata || {};
@@ -14525,7 +13542,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
         }
       };
       var LinkedInAdsConnector = class LinkedInAdsConnector extends AbstractConnector2 {
-        constructor(config, source, storageName = "GoogleSheetsStorage", runConfig = null) {
+        constructor(config, source, storageName = "GoogleBigQueryStorage", runConfig = null) {
           super(config, source, null, runConfig);
           this.storageName = storageName;
         }
@@ -14533,11 +13550,11 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * Main method - entry point for the import process
          * Processes all nodes defined in the fields configuration
          */
-        startImportProcess() {
+        async startImportProcess() {
           const urns = FormatUtils.parseIds(this.config.AccountURNs.value, { prefix: "urn:li:sponsoredAccount:" });
           const dataSources = FormatUtils.parseFields(this.config.Fields.value);
           for (const nodeName in dataSources) {
-            this.processNode({
+            await this.processNode({
               nodeName,
               urns,
               fields: dataSources[nodeName] || []
@@ -14551,13 +13568,13 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Array} options.urns - URNs to process
          * @param {Array} options.fields - Fields to fetch
          */
-        processNode({ nodeName, urns, fields }) {
+        async processNode({ nodeName, urns, fields }) {
           const isTimeSeriesNode = ConnectorUtils.isTimeSeriesNode(this.source.fieldsSchema[nodeName]);
           const dateInfo = this.prepareDateRangeIfNeeded(nodeName, isTimeSeriesNode);
           if (isTimeSeriesNode && !dateInfo) {
             return;
           }
-          this.fetchAndSaveData({
+          await this.fetchAndSaveData({
             nodeName,
             urns,
             fields,
@@ -14578,16 +13595,17 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} [options.startDate] - Start date for time series data
          * @param {string} [options.endDate] - End date for time series data
          */
-        fetchAndSaveData({ nodeName, urns, fields, isTimeSeriesNode, startDate, endDate }) {
+        async fetchAndSaveData({ nodeName, urns, fields, isTimeSeriesNode, startDate, endDate }) {
           var _a;
           for (const urn of urns) {
             console.log(`Processing ${nodeName} for ${urn}${isTimeSeriesNode ? ` from ${startDate} to ${endDate}` : ""}`);
             const params = { fields, ...isTimeSeriesNode && { startDate, endDate } };
-            const data = this.source.fetchData(nodeName, urn, params);
+            const data = await this.source.fetchData(nodeName, urn, params);
             this.config.logMessage(data.length ? `${data.length} rows of ${nodeName} were fetched for ${urn}${endDate ? ` from ${startDate} to ${endDate}` : ""}` : `No records have been fetched`);
             if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
               const preparedData = data.length ? this.addMissingFieldsToData(data, fields) : data;
-              this.getStorageByNode(nodeName).saveData(preparedData);
+              const storage = await this.getStorageByNode(nodeName);
+              await storage.saveData(preparedData);
             }
           }
         }
@@ -14596,7 +13614,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} nodeName - Name of the node
          * @returns {Object} - Storage instance
          */
-        getStorageByNode(nodeName) {
+        async getStorageByNode(nodeName) {
           if (!("storages" in this)) {
             this.storages = {};
           }
@@ -14614,6 +13632,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
               this.source.fieldsSchema[nodeName]["fields"],
               `${this.source.fieldsSchema[nodeName]["description"]} ${this.source.fieldsSchema[nodeName]["documentation"]}`
             );
+            await this.storages[nodeName].init();
           }
           return this.storages[nodeName];
         }
@@ -14650,7 +13669,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
       };
     })();
     const GoogleAds = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
+      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils2, FileUtils: FileUtils2, DateUtils: DateUtils2, CryptoUtils: CryptoUtils2, AsyncUtils: AsyncUtils2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
       var keywordStatsFields = {
         "keyword_id": {
           "description": "Keyword Criterion ID",
@@ -15551,7 +14570,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * Get access token based on authentication type
          * Supports OAuth2 and Service Account authentication
          */
-        getAccessToken() {
+        async getAccessToken() {
           var _a;
           if (this.accessToken && this.tokenExpiryTime && Date.now() < this.tokenExpiryTime) {
             return this.accessToken;
@@ -15564,7 +14583,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
           let accessToken;
           try {
             if (authType === "oauth2") {
-              accessToken = OAuthUtils.getAccessToken({
+              accessToken = await OAuthUtils.getAccessToken({
                 config: this.config,
                 tokenUrl: "https://oauth2.googleapis.com/token",
                 formData: {
@@ -15575,7 +14594,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
                 }
               });
             } else if (authType === "service_account") {
-              accessToken = OAuthUtils.getServiceAccountToken({
+              accessToken = await OAuthUtils.getServiceAccountToken({
                 config: this.config,
                 tokenUrl: "https://oauth2.googleapis.com/token",
                 serviceAccountKeyJson: authConfig.ServiceAccountKey.value,
@@ -15602,11 +14621,12 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Date} [options.startDate] - Start date for time series data
          * @returns {Array<Object>} - Fetched data
          */
-        fetchData(nodeName, customerId, options) {
+        async fetchData(nodeName, customerId, options) {
           console.log("Fetching data from Google Ads API for customer:", customerId);
           const { fields, startDate } = options;
           const query = this._buildQuery({ nodeName, fields, startDate });
-          return this.makeRequest({ customerId, query, nodeName, fields });
+          const response = await this.makeRequest({ customerId, query, nodeName, fields });
+          return await response;
         }
         /**
          * Convert field names to API field names
@@ -15656,7 +14676,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
           const resourceName = this._getResourceName(nodeName);
           let query = `SELECT ${apiFields.join(", ")} FROM ${resourceName}`;
           if (startDate && this.fieldsSchema[nodeName].isTimeSeries) {
-            const formattedDate = EnvironmentAdapter2.formatDate(startDate, "UTC", "yyyy-MM-dd");
+            const formattedDate = DateUtils2.formatDate(startDate);
             query += ` WHERE segments.date = '${formattedDate}'`;
           }
           return query;
@@ -15670,9 +14690,9 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Array<string>} options.fields - Fields that were requested
          * @returns {Array<Object>} - API response data
          */
-        makeRequest({ customerId, query, nodeName, fields }) {
+        async makeRequest({ customerId, query, nodeName, fields }) {
           var _a, _b;
-          const accessToken = this.getAccessToken();
+          const accessToken = await this.getAccessToken();
           const url = `https://googleads.googleapis.com/v21/customers/${customerId}/googleAds:search`;
           console.log(`Google Ads API Request URL: ${url}`);
           console.log(`GAQL Query: ${query}`);
@@ -15696,8 +14716,9 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
               body: JSON.stringify(requestBody),
               muteHttpExceptions: true
             };
-            const response = this.urlFetchWithRetry(url, options);
-            const jsonData = JSON.parse(response.getContentText());
+            const response = await this.urlFetchWithRetry(url, options);
+            const text = await response.getContentText();
+            const jsonData = JSON.parse(text);
             if (jsonData.error) {
               throw new Error(`Google Ads API error: ${jsonData.error.message}`);
             }
@@ -15752,7 +14773,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
         }
       };
       var GoogleAdsConnector = class GoogleAdsConnector extends AbstractConnector2 {
-        constructor(config, source, storageName = "GoogleSheetsStorage", runConfig = null) {
+        constructor(config, source, storageName = "GoogleBigQueryStorage", runConfig = null) {
           super(config, source, null, runConfig);
           this.storageName = storageName;
         }
@@ -15760,11 +14781,11 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * Main method - entry point for the import process
          * Processes all nodes defined in the fields configuration
          */
-        startImportProcess() {
+        async startImportProcess() {
           const customerIds = FormatUtils.parseIds(this.config.CustomerId.value, { stripCharacters: "-" });
           const fields = FormatUtils.parseFields(this.config.Fields.value);
           for (const nodeName in fields) {
-            this.processNode({
+            await this.processNode({
               nodeName,
               customerIds,
               fields: fields[nodeName] || []
@@ -15778,16 +14799,16 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Array<string>} options.customerIds - Array of customer IDs to process
          * @param {Array<string>} options.fields - Array of fields to fetch
          */
-        processNode({ nodeName, customerIds, fields }) {
+        async processNode({ nodeName, customerIds, fields }) {
           for (const customerId of customerIds) {
             if (this.source.fieldsSchema[nodeName].isTimeSeries) {
-              this.processTimeSeriesNode({
+              await this.processTimeSeriesNode({
                 nodeName,
                 customerId,
                 fields
               });
             } else {
-              this.processCatalogNode({
+              await this.processCatalogNode({
                 nodeName,
                 customerId,
                 fields
@@ -15802,7 +14823,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} options.customerId - Customer ID
          * @param {Array<string>} options.fields - Array of fields to fetch
          */
-        processTimeSeriesNode({ nodeName, customerId, fields }) {
+        async processTimeSeriesNode({ nodeName, customerId, fields }) {
           var _a;
           const [startDate, daysToFetch] = this.getStartDateAndDaysToFetch();
           if (daysToFetch <= 0) {
@@ -15812,12 +14833,13 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
           for (let i = 0; i < daysToFetch; i++) {
             const currentDate = new Date(startDate);
             currentDate.setDate(currentDate.getDate() + i);
-            const formattedDate = EnvironmentAdapter2.formatDate(currentDate, "UTC", "yyyy-MM-dd");
-            const data = this.source.fetchData(nodeName, customerId, { fields, startDate: currentDate });
+            const formattedDate = DateUtils2.formatDate(currentDate);
+            const data = await this.source.fetchData(nodeName, customerId, { fields, startDate: currentDate });
             this.config.logMessage(data.length ? `${data.length} rows of ${nodeName} were fetched for customer ${customerId} on ${formattedDate}` : `ℹ️ No records have been fetched`);
             if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
               const preparedData = data.length ? this.addMissingFieldsToData(data, fields) : data;
-              this.getStorageByNode(nodeName).saveData(preparedData);
+              const storage = await this.getStorageByNode(nodeName);
+              await storage.saveData(preparedData);
             }
             if (this.runConfig.type === RUN_CONFIG_TYPE2.INCREMENTAL) {
               this.config.updateLastRequstedDate(currentDate);
@@ -15831,13 +14853,14 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} options.customerId - Customer ID
          * @param {Array<string>} options.fields - Array of fields to fetch
          */
-        processCatalogNode({ nodeName, customerId, fields }) {
+        async processCatalogNode({ nodeName, customerId, fields }) {
           var _a;
-          const data = this.source.fetchData(nodeName, customerId, { fields });
+          const data = await this.source.fetchData(nodeName, customerId, { fields });
           this.config.logMessage(data.length ? `${data.length} rows of ${nodeName} were fetched for customer ${customerId}` : `ℹ️ No records have been fetched`);
           if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
             const preparedData = data.length ? this.addMissingFieldsToData(data, fields) : data;
-            this.getStorageByNode(nodeName).saveData(preparedData);
+            const storage = await this.getStorageByNode(nodeName);
+            await storage.saveData(preparedData);
           }
         }
         /**
@@ -15845,7 +14868,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} nodeName - Name of the node
          * @returns {Object} - Storage instance
          */
-        getStorageByNode(nodeName) {
+        async getStorageByNode(nodeName) {
           if (!("storages" in this)) {
             this.storages = {};
           }
@@ -15863,6 +14886,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
               this.source.fieldsSchema[nodeName].fields,
               `${this.source.fieldsSchema[nodeName].description} ${this.source.fieldsSchema[nodeName].documentation}`
             );
+            await this.storages[nodeName].init();
           }
           return this.storages[nodeName];
         }
@@ -15879,7 +14903,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
       };
     })();
     const GitHub = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
+      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils2, FileUtils: FileUtils2, DateUtils: DateUtils2, CryptoUtils: CryptoUtils2, AsyncUtils: AsyncUtils2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
       var repositoryStatsFields = {
         date: {
           type: "date",
@@ -16192,16 +15216,16 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Array<string>} opts.fields
          * @returns {Array<Object>}
          */
-        fetchData({ nodeName, fields = [] }) {
+        async fetchData({ nodeName, fields = [] }) {
           switch (nodeName) {
             case "repository":
-              const repoData = this.makeRequest({ endpoint: `repos/${this.config.RepositoryName.value}` });
+              const repoData = await this.makeRequest({ endpoint: `repos/${this.config.RepositoryName.value}` });
               return this._filterBySchema({ items: [repoData], nodeName, fields });
             case "contributors":
-              const contribData = this.makeRequest({ endpoint: `repos/${this.config.RepositoryName.value}/contributors?per_page=1000` });
+              const contribData = await this.makeRequest({ endpoint: `repos/${this.config.RepositoryName.value}/contributors?per_page=1000` });
               return this._filterBySchema({ items: contribData, nodeName, fields });
             case "repositoryStats":
-              return this._fetchRepositoryStats({ nodeName, fields });
+              return await this._fetchRepositoryStats({ nodeName, fields });
             default:
               throw new Error(`Unknown node: ${nodeName}`);
           }
@@ -16213,9 +15237,9 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Array<string>} options.fields - Array of fields to fetch
          * @returns {Array} Array of repository statistics data
          */
-        _fetchRepositoryStats({ nodeName, fields }) {
-          const repoData = this.makeRequest({ endpoint: `repos/${this.config.RepositoryName.value}` });
-          const contribData = this.makeRequest({ endpoint: `repos/${this.config.RepositoryName.value}/contributors?per_page=1000` });
+        async _fetchRepositoryStats({ nodeName, fields }) {
+          const repoData = await this.makeRequest({ endpoint: `repos/${this.config.RepositoryName.value}` });
+          const contribData = await this.makeRequest({ endpoint: `repos/${this.config.RepositoryName.value}/contributors?per_page=1000` });
           return this._filterBySchema({
             items: [{
               "date": new Date((/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0)),
@@ -16232,30 +15256,32 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} options.endpoint - API endpoint path (e.g., "repos/owner/repo")
          * @returns {Object} - API response parsed from JSON
          */
-        makeRequest({ endpoint }) {
-          const baseUrl = "https://api.github.com/";
-          const url = `${baseUrl}${endpoint}`;
-          const response = EnvironmentAdapter2.fetch(url, {
-            "method": "get",
-            "muteHttpExceptions": true,
-            "headers": {
-              "Accept": "application/vnd.github+json",
-              "Authorization": `Bearer ${this.config.AccessToken.value}`,
-              "User-Agent": "owox"
+        async makeRequest({ endpoint }) {
+          try {
+            const baseUrl = "https://api.github.com/";
+            const url = `${baseUrl}${endpoint}`;
+            const response = await HttpUtils2.fetch(url, {
+              "method": "get",
+              "muteHttpExceptions": true,
+              "headers": {
+                "Accept": "application/vnd.github+json",
+                "Authorization": `Bearer ${this.config.AccessToken.value}`,
+                "User-Agent": "owox"
+              }
+            });
+            const text = await response.getContentText();
+            const result = JSON.parse(text);
+            if (result && result.message === "Not Found") {
+              throw new Error(
+                "The repository was not found. The repository name should be in the format: owner/repo"
+              );
             }
-          });
-          const result = JSON.parse(response.getContentText());
-          if (result && result.message === "Not Found") {
-            throw new Error(
-              "The repository was not found. The repository name should be in the format: owner/repo"
-            );
+            return result;
+          } catch (error) {
+            this.config.logMessage(`Error: ${error.message}`);
+            console.error(error.stack);
+            throw error;
           }
-          return result;
-        }
-        catch(error) {
-          this.config.logMessage(`Error: ${error.message}`);
-          console.error(error.stack);
-          throw error;
         }
         /**
          * Keep only requestedFields plus any schema-required keys.
@@ -16281,7 +15307,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
         }
       };
       var GitHubConnector = class GitHubConnector extends AbstractConnector2 {
-        constructor(config, source, storageName = "GoogleSheetsStorage", runConfig = null) {
+        constructor(config, source, storageName = "GoogleBigQueryStorage", runConfig = null) {
           super(config, source, null, runConfig);
           this.storageName = storageName;
         }
@@ -16289,10 +15315,10 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * Main method - entry point for the import process
          * Processes all nodes defined in the fields configuration
          */
-        startImportProcess() {
+        async startImportProcess() {
           const fields = ConnectorUtils.parseFields(this.config.Fields.value);
           for (const nodeName in fields) {
-            this.processNode({
+            await this.processNode({
               nodeName,
               fields: fields[nodeName] || []
             });
@@ -16304,11 +15330,11 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} options.nodeName - Name of the node to process
          * @param {Array<string>} options.fields - Array of fields to fetch
          */
-        processNode({ nodeName, fields }) {
+        async processNode({ nodeName, fields }) {
           if (ConnectorUtils.isTimeSeriesNode(this.source.fieldsSchema[nodeName])) {
-            this.processTimeSeriesNode({ nodeName, fields });
+            await this.processTimeSeriesNode({ nodeName, fields });
           } else {
-            this.processCatalogNode({ nodeName, fields });
+            await this.processCatalogNode({ nodeName, fields });
           }
         }
         /**
@@ -16318,7 +15344,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Array<string>} options.fields - Array of fields to fetch
          * @param {Object} options.storage - Storage instance
          */
-        processTimeSeriesNode({ nodeName, fields }) {
+        async processTimeSeriesNode({ nodeName, fields }) {
           console.log(`Time series node processing not implemented for ${nodeName}`);
         }
         /**
@@ -16328,13 +15354,14 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Array<string>} options.fields - Array of fields to fetch
          * @param {Object} options.storage - Storage instance
          */
-        processCatalogNode({ nodeName, fields }) {
+        async processCatalogNode({ nodeName, fields }) {
           var _a;
-          const data = this.source.fetchData({ nodeName, fields });
+          const data = await this.source.fetchData({ nodeName, fields });
           this.config.logMessage(data.length ? `${data.length} rows of ${nodeName} were fetched` : `No records have been fetched`);
           if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
             const preparedData = data.length ? this.addMissingFieldsToData(data, fields) : data;
-            this.getStorageByNode(nodeName).saveData(preparedData);
+            const storage = await this.getStorageByNode(nodeName);
+            await storage.saveData(preparedData);
           }
         }
         /**
@@ -16342,7 +15369,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} nodeName - Name of the node
          * @returns {Object} Storage instance
          */
-        getStorageByNode(nodeName) {
+        async getStorageByNode(nodeName) {
           if (!("storages" in this)) {
             this.storages = {};
           }
@@ -16360,6 +15387,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
               this.source.fieldsSchema[nodeName].fields,
               `${this.source.fieldsSchema[nodeName].description} ${this.source.fieldsSchema[nodeName].documentation}`
             );
+            await this.storages[nodeName].init();
           }
           return this.storages[nodeName];
         }
@@ -16376,7 +15404,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
       };
     })();
     const FacebookMarketing = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
+      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils2, FileUtils: FileUtils2, DateUtils: DateUtils2, CryptoUtils: CryptoUtils2, AsyncUtils: AsyncUtils2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
       var adGroupFields = {
         "id": {
           "description": "The ID of this ad.",
@@ -20881,12 +19909,12 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
           @return data array
         
           */
-        fetchData(nodeName, accountId, fields, startDate = null) {
+        async fetchData(nodeName, accountId, fields, startDate = null) {
           let url = "https://graph.facebook.com/v23.0/";
           let formattedDate = null;
           let timeRange = null;
           if (startDate) {
-            formattedDate = EnvironmentAdapter2.formatDate(startDate, "UTC", "yyyy-MM-dd");
+            formattedDate = DateUtils2.formatDate(startDate);
             timeRange = encodeURIComponent(JSON.stringify({ since: formattedDate, until: formattedDate }));
           }
           switch (nodeName) {
@@ -20910,7 +19938,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             case "ad-account/insights-by-region":
             case "ad-account/insights-by-product-id":
             case "ad-account/insights-by-age-and-gender":
-              return this._fetchInsightsData({ nodeName, accountId, fields, timeRange, url });
+              return await this._fetchInsightsData({ nodeName, accountId, fields, timeRange, url });
             case "ad-group":
               url += `act_${accountId}/ads?fields=${this._buildFieldsString({ nodeName, fields })}&limit=${this.fieldsSchema[nodeName].limit}`;
               break;
@@ -20919,7 +19947,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
           }
           console.log(`Facebook API URL:`, url);
           url += `&access_token=${this.config.AccessToken.value}`;
-          return this._fetchPaginatedData(url, nodeName, fields);
+          return await this._fetchPaginatedData(url, nodeName, fields);
         }
         //---- castRecordFields -------------------------------------------------
         /**
@@ -20981,7 +20009,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @return {Array} Processed insights data
          * @private
          */
-        _fetchInsightsData({ nodeName, accountId, fields, timeRange, url }) {
+        async _fetchInsightsData({ nodeName, accountId, fields, timeRange, url }) {
           const breakdowns = this.fieldsSchema[nodeName].breakdowns || [];
           const regularFields = this._prepareFields({ nodeName, fields, breakdowns });
           const requestUrl = this._buildInsightsUrl({
@@ -20992,7 +20020,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             nodeName,
             url
           });
-          const allData = this._fetchPaginatedData(requestUrl, nodeName, fields);
+          const allData = await this._fetchPaginatedData(requestUrl, nodeName, fields);
           if (this.config.ProcessShortLinks.value && allData.length > 0 && allData.some((record) => record.link_url_asset)) {
             return processShortLinks(allData, {
               shortLinkField: "link_url_asset",
@@ -21133,12 +20161,13 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @return {Array} All fetched data
          * @private
          */
-        _fetchPaginatedData(initialUrl, nodeName, fields) {
+        async _fetchPaginatedData(initialUrl, nodeName, fields) {
           var allData = [];
           var nextPageURL = initialUrl;
           while (nextPageURL) {
-            var response = this.urlFetchWithRetry(nextPageURL);
-            var jsonData = JSON.parse(response.getContentText());
+            var response = await this.urlFetchWithRetry(nextPageURL);
+            var text = await response.getContentText();
+            var jsonData = JSON.parse(text);
             if ("data" in jsonData) {
               nextPageURL = jsonData.paging ? jsonData.paging.next : null;
               jsonData.data.forEach((record, index) => {
@@ -21161,12 +20190,12 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
       };
       var FacebookMarketingConnector = class FacebookMarketingConnector extends AbstractConnector2 {
         // ---- constructor ------------------------------------
-        constructor(config, source, storageName = "GoogleSheetsStorage", runConfig = null) {
+        constructor(config, source, storageName = "GoogleBigQueryStorage", runConfig = null) {
           super(config, source, null, runConfig);
           this.storageName = storageName;
         }
         //---- startImportProcess -------------------------------------------------
-        startImportProcess() {
+        async startImportProcess() {
           let accountsIds = String(this.config.AccoundIDs.value).split(/[,;]\s*/);
           let fields = this.config.Fields.value.split(", ").reduce((acc, pair) => {
             let [key, value] = pair.split(" ");
@@ -21178,7 +20207,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             if (nodeName in this.source.fieldsSchema && this.source.fieldsSchema[nodeName].isTimeSeries) {
               timeSeriesNodes[nodeName] = fields[nodeName];
             } else {
-              this.startImportProcessOfCatalogData(nodeName, accountsIds, fields[nodeName]);
+              await this.startImportProcessOfCatalogData(nodeName, accountsIds, fields[nodeName]);
             }
           }
           if (Object.keys(timeSeriesNodes).length > 0) {
@@ -21186,27 +20215,28 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             let daysToFetch = null;
             [startDate, daysToFetch] = this.getStartDateAndDaysToFetch();
             if (daysToFetch > 0) {
-              this.startImportProcessOfTimeSeriesData(accountsIds, timeSeriesNodes, startDate, daysToFetch);
+              await this.startImportProcessOfTimeSeriesData(accountsIds, timeSeriesNodes, startDate, daysToFetch);
             }
           }
         }
         //---- startImportProcessOfCatalogData -------------------------------------------------
         /*
         
-            Imports catalog (not time seriesed) data 
+            Imports catalog (not time seriesed) data
         
             @param nodeName string Node name
             @param accountsIds array list of account ids
-            @param fields array list of fields 
+            @param fields array list of fields
         
             */
-        startImportProcessOfCatalogData(nodeName, accountIds, fields) {
+        async startImportProcessOfCatalogData(nodeName, accountIds, fields) {
           var _a;
           for (var i in accountIds) {
             let accountId = accountIds[i];
-            let data = this.source.fetchData(nodeName, accountId, fields);
+            let data = await this.source.fetchData(nodeName, accountId, fields);
             if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
-              this.getStorageByNode(nodeName).saveData(data);
+              const storage = await this.getStorageByNode(nodeName);
+              await storage.saveData(data);
             }
             data.length && this.config.logMessage(`${data.length} rows of ${nodeName} were fetched for account ${accountId}`);
           }
@@ -21214,23 +20244,24 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
         //---- startImportProcessOfTimeSeriesData -------------------------------------------------
         /*
         
-            Imports time series (not catalog) data 
+            Imports time series (not catalog) data
         
             @param accountsIds (array) list of account ids
             @param timeSeriesNodes (object) of properties, each is array of fields
-            @param startDate (Data) start date 
+            @param startDate (Data) start date
             @param daysToFetch (integer) days to import
         
             */
-        startImportProcessOfTimeSeriesData(accountsIds, timeSeriesNodes, startDate, daysToFetch = 1) {
+        async startImportProcessOfTimeSeriesData(accountsIds, timeSeriesNodes, startDate, daysToFetch = 1) {
           var _a;
           for (var daysShift = 0; daysShift < daysToFetch; daysShift++) {
             for (let accountId of accountsIds) {
               for (var nodeName in timeSeriesNodes) {
-                this.config.logMessage(`Start importing data for ${EnvironmentAdapter2.formatDate(startDate, "UTC", "yyyy-MM-dd")}: ${accountId}/${nodeName}`);
-                let data = this.source.fetchData(nodeName, accountId, timeSeriesNodes[nodeName], startDate);
+                this.config.logMessage(`Start importing data for ${DateUtils2.formatDate(startDate)}: ${accountId}/${nodeName}`);
+                let data = await this.source.fetchData(nodeName, accountId, timeSeriesNodes[nodeName], startDate);
                 if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
-                  this.getStorageByNode(nodeName).saveData(data);
+                  const storage = await this.getStorageByNode(nodeName);
+                  await storage.saveData(data);
                 }
                 this.config.logMessage(data.length ? `${data.length} records were fetched` : `No records have been fetched`);
               }
@@ -21250,7 +20281,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @return AbstractStorage 
          * 
          */
-        getStorageByNode(nodeName) {
+        async getStorageByNode(nodeName) {
           if (!("storages" in this)) {
             this.storages = {};
           }
@@ -21268,6 +20299,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
               this.source.fieldsSchema[nodeName]["fields"],
               `${this.source.fieldsSchema[nodeName]["description"]} ${this.source.fieldsSchema[nodeName]["documentation"]}`
             );
+            await this.storages[nodeName].init();
           }
           return this.storages[nodeName];
         }
@@ -21284,7 +20316,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
       };
     })();
     const CriteoAds = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
+      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils2, FileUtils: FileUtils2, DateUtils: DateUtils2, CryptoUtils: CryptoUtils2, AsyncUtils: AsyncUtils2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
       var CriteoAdsHelper = {
         /**
          * Parse fields string into a structured object
@@ -22131,10 +21163,10 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Date} opts.date
          * @returns {Array<Object>}
          */
-        fetchData({ nodeName, accountId, fields = [], date }) {
+        async fetchData({ nodeName, accountId, fields = [], date }) {
           switch (nodeName) {
             case "statistics":
-              return this._fetchStatistics({ accountId, fields, date });
+              return await this._fetchStatistics({ accountId, fields, date });
             default:
               throw new Error(`Unknown node: ${nodeName}`);
           }
@@ -22148,16 +21180,17 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @returns {Array<Object>} - Parsed and enriched data
          * @private
          */
-        _fetchStatistics({ accountId, fields, date }) {
+        async _fetchStatistics({ accountId, fields, date }) {
           const uniqueKeys = this.fieldsSchema.statistics.uniqueKeys || [];
           const missingKeys = uniqueKeys.filter((key) => !fields.includes(key));
           if (missingKeys.length > 0) {
             throw new Error(`Missing required unique fields for endpoint 'statistics'. Missing fields: ${missingKeys.join(", ")}`);
           }
-          this.getAccessToken();
+          await this.getAccessToken();
           const requestBody = this._buildStatisticsRequestBody({ accountId, fields, date });
-          const response = this._makeApiRequest(requestBody);
-          const jsonObject = JSON.parse(response.getContentText());
+          const response = await this._makeApiRequest(requestBody);
+          const text = await response.getContentText();
+          const jsonObject = JSON.parse(text);
           return this.parseApiResponse({ apiResponse: jsonObject, date, accountId, fields });
         }
         /**
@@ -22195,7 +21228,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @returns {Object} - HTTP response
          * @private
          */
-        _makeApiRequest(requestBody) {
+        async _makeApiRequest(requestBody) {
           const apiVersion = "2025-07";
           const apiUrl = `https://api.criteo.com/${apiVersion}/statistics/report`;
           const options = {
@@ -22209,19 +21242,20 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             body: JSON.stringify(requestBody)
             // TODO: body is for Node.js; refactor to centralize JSON option creation
           };
-          const response = this.urlFetchWithRetry(apiUrl, options);
+          const response = await this.urlFetchWithRetry(apiUrl, options);
           const responseCode = response.getResponseCode();
           if (responseCode === HTTP_STATUS2.OK) {
             return response;
           } else {
-            throw new Error(`API Error (${responseCode}): ${response.getContentText()}`);
+            const text = await response.getContentText();
+            throw new Error(`API Error (${responseCode}): ${text}`);
           }
         }
         /**
          * Get access token from API
          * Docs: https://developers.criteo.com/marketing-solutions/docs/authorization-code-setup
          */
-        getAccessToken() {
+        async getAccessToken() {
           var _a;
           if ((_a = this.config.AccessToken) == null ? void 0 : _a.value) {
             return;
@@ -22244,8 +21278,9 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             muteHttpExceptions: true
           };
           try {
-            const response = this.urlFetchWithRetry(tokenUrl, options);
-            const responseData = JSON.parse(response.getContentText());
+            const response = await this.urlFetchWithRetry(tokenUrl, options);
+            const text = await response.getContentText();
+            const responseData = JSON.parse(text);
             const accessToken = responseData["access_token"];
             this.config.AccessToken = {
               value: accessToken
@@ -22293,20 +21328,20 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
         }
       };
       var CriteoAdsConnector = class CriteoAdsConnector extends AbstractConnector2 {
-        constructor(config, source, storageName = "GoogleSheetsStorage", runConfig = null) {
+        constructor(config, source, storageName = "GoogleBigQueryStorage", runConfig = null) {
           super(config, source, null, runConfig);
           this.storageName = storageName;
         }
         /**
          * Main method - entry point for the import process
          */
-        startImportProcess() {
+        async startImportProcess() {
           var _a, _b;
           const fields = CriteoAdsHelper.parseFields(((_a = this.config.Fields) == null ? void 0 : _a.value) || "");
           const advertiserIds = CriteoAdsHelper.parseAdvertiserIds(((_b = this.config.AdvertiserIDs) == null ? void 0 : _b.value) || "");
           for (const advertiserId of advertiserIds) {
             for (const nodeName in fields) {
-              this.processNode({
+              await this.processNode({
                 nodeName,
                 advertiserId,
                 fields: fields[nodeName] || []
@@ -22321,8 +21356,8 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} options.advertiserId - Advertiser ID
          * @param {Array<string>} options.fields - Array of fields to fetch
          */
-        processNode({ nodeName, advertiserId, fields }) {
-          this.processTimeSeriesNode({
+        async processNode({ nodeName, advertiserId, fields }) {
+          await this.processTimeSeriesNode({
             nodeName,
             advertiserId,
             fields
@@ -22336,7 +21371,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Array<string>} options.fields - Array of fields to fetch
          * @param {Object} options.storage - Storage instance
          */
-        processTimeSeriesNode({ nodeName, advertiserId, fields }) {
+        async processTimeSeriesNode({ nodeName, advertiserId, fields }) {
           var _a;
           const [startDate, daysToFetch] = this.getStartDateAndDaysToFetch();
           if (daysToFetch <= 0) {
@@ -22346,8 +21381,8 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
           for (let i = 0; i < daysToFetch; i++) {
             const currentDate = new Date(startDate);
             currentDate.setDate(currentDate.getDate() + i);
-            const formattedDate = EnvironmentAdapter2.formatDate(currentDate, "UTC", "yyyy-MM-dd");
-            const data = this.source.fetchData({
+            const formattedDate = DateUtils2.formatDate(currentDate);
+            const data = await this.source.fetchData({
               nodeName,
               accountId: advertiserId,
               date: currentDate,
@@ -22356,7 +21391,8 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
             this.config.logMessage(data.length ? `${data.length} rows of ${nodeName} were fetched for ${advertiserId} on ${formattedDate}` : `No records have been fetched`);
             if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
               const preparedData = data.length ? this.addMissingFieldsToData(data, fields) : data;
-              this.getStorageByNode(nodeName).saveData(preparedData);
+              const storage = await this.getStorageByNode(nodeName);
+              await storage.saveData(preparedData);
             }
             if (this.runConfig.type === RUN_CONFIG_TYPE2.INCREMENTAL) {
               this.config.updateLastRequstedDate(currentDate);
@@ -22368,7 +21404,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} nodeName - Name of the node
          * @returns {Object} Storage instance
          */
-        getStorageByNode(nodeName) {
+        async getStorageByNode(nodeName) {
           if (!("storages" in this)) {
             this.storages = {};
           }
@@ -22386,6 +21422,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
               this.source.fieldsSchema[nodeName].fields,
               `${this.source.fieldsSchema[nodeName].description} ${this.source.fieldsSchema[nodeName].documentation}`
             );
+            await this.storages[nodeName].init();
           }
           return this.storages[nodeName];
         }
@@ -22402,7 +21439,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
       };
     })();
     const BankOfCanada = (function() {
-      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, EnvironmentAdapter: EnvironmentAdapter2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, ENVIRONMENT: ENVIRONMENT2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
+      const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, UnsupportedEnvironmentException: UnsupportedEnvironmentException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource2, AbstractRunConfig: AbstractRunConfig2, AbstractConnector: AbstractConnector2, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils2, FileUtils: FileUtils2, DateUtils: DateUtils2, CryptoUtils: CryptoUtils2, AsyncUtils: AsyncUtils2, RunConfigDto: RunConfigDto2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2 } = Core;
       var observationsFields = {
         "date": {
           "description": "The date for which the exchange rate was recorded.",
@@ -22480,10 +21517,10 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} [opts.end_time]
          * @returns {Array<Object>}
          */
-        fetchData({ nodeName, fields = [], start_time, end_time }) {
+        async fetchData({ nodeName, fields = [], start_time, end_time }) {
           switch (nodeName) {
             case "observations/group":
-              return this._fetchObservations({ fields, start_time, end_time });
+              return await this._fetchObservations({ fields, start_time, end_time });
             default:
               throw new Error(`Unknown node: ${nodeName}`);
           }
@@ -22496,8 +21533,8 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} opts.end_time
          * @returns {Array<Object>}
          */
-        _fetchObservations({ fields, start_time, end_time }) {
-          const rates = this.makeRequest({
+        async _fetchObservations({ fields, start_time, end_time }) {
+          const rates = await this.makeRequest({
             endpoint: `observations/group/FX_RATES_DAILY/json?start_date=${start_time}&end_date=${end_time}`
           });
           let data = [];
@@ -22519,13 +21556,13 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} options.endpoint - API endpoint path (e.g., "observations/group/FX_RATES_DAILY/json")
          * @returns {Object} - API response parsed from JSON
          */
-        makeRequest({ endpoint }) {
+        async makeRequest({ endpoint }) {
           const baseUrl = "https://www.bankofcanada.ca/valet/";
           const url = `${baseUrl}${endpoint}`;
           console.log(`Bank of Canada API Request URL:`, url);
-          const response = EnvironmentAdapter2.fetch(url, { "method": "get", "muteHttpExceptions": true });
-          const result = JSON.parse(response.getContentText());
-          return result;
+          const response = await HttpUtils2.fetch(url, { "method": "get", "muteHttpExceptions": true });
+          const result = await response.getContentText();
+          return JSON.parse(result);
         }
         /**
          * Keep only requestedFields plus any schema-required keys.
@@ -22550,7 +21587,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
         }
       };
       var BankOfCanadaConnector = class BankOfCanadaConnector extends AbstractConnector2 {
-        constructor(config, source, storageName = "GoogleSheetsStorage", runConfig = null) {
+        constructor(config, source, storageName = "GoogleBigQueryStorage", runConfig = null) {
           super(config, source, null, runConfig);
           this.storageName = storageName;
         }
@@ -22558,10 +21595,10 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * Main method - entry point for the import process
          * Processes all nodes defined in the fields configuration
          */
-        startImportProcess() {
+        async startImportProcess() {
           const fields = ConnectorUtils.parseFields(this.config.Fields.value);
           for (const nodeName in fields) {
-            this.processNode({
+            await this.processNode({
               nodeName,
               fields: fields[nodeName] || []
             });
@@ -22573,11 +21610,11 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} options.nodeName - Name of the node to process
          * @param {Array<string>} options.fields - Array of fields to fetch
          */
-        processNode({ nodeName, fields }) {
+        async processNode({ nodeName, fields }) {
           if (this.source.fieldsSchema[nodeName].isTimeSeries) {
-            this.processTimeSeriesNode({ nodeName, fields });
+            await this.processTimeSeriesNode({ nodeName, fields });
           } else {
-            this.processCatalogNode({ nodeName, fields });
+            await this.processCatalogNode({ nodeName, fields });
           }
         }
         /**
@@ -22587,14 +21624,14 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Array<string>} options.fields - Array of fields to fetch
          * @param {Object} options.storage - Storage instance
          */
-        processTimeSeriesNode({ nodeName, fields }) {
+        async processTimeSeriesNode({ nodeName, fields }) {
           var _a;
           const dateRange = this.prepareDateRange();
           if (!dateRange) {
             console.log("No days to fetch for time series data");
             return;
           }
-          const data = this.source.fetchData({
+          const data = await this.source.fetchData({
             nodeName,
             start_time: dateRange.startDate,
             end_time: dateRange.endDate,
@@ -22603,7 +21640,8 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
           this.config.logMessage(data.length ? `${data.length} rows of ${nodeName} were fetched from ${dateRange.startDate} to ${dateRange.endDate}` : `No records have been fetched`);
           if (data.length || ((_a = this.config.CreateEmptyTables) == null ? void 0 : _a.value)) {
             const preparedData = data.length ? this.addMissingFieldsToData(data, fields) : data;
-            this.getStorageByNode(nodeName).saveData(preparedData);
+            const storage = await this.getStorageByNode(nodeName);
+            await storage.saveData(preparedData);
           }
           if (this.runConfig.type === RUN_CONFIG_TYPE2.INCREMENTAL) {
             this.config.updateLastRequstedDate(new Date(dateRange.endDate));
@@ -22616,7 +21654,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {Array<string>} options.fields - Array of fields to fetch
          * @param {Object} options.storage - Storage instance
          */
-        processCatalogNode({ nodeName, fields }) {
+        async processCatalogNode({ nodeName, fields }) {
           console.log(`Catalog node processing not implemented for ${nodeName}`);
         }
         /**
@@ -22624,7 +21662,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
          * @param {string} nodeName - Name of the node
          * @returns {Object} Storage instance
          */
-        getStorageByNode(nodeName) {
+        async getStorageByNode(nodeName) {
           if (!("storages" in this)) {
             this.storages = {};
           }
@@ -22642,6 +21680,7 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
               this.source.fieldsSchema[nodeName].fields,
               `${this.source.fieldsSchema[nodeName].description} ${this.source.fieldsSchema[nodeName].documentation}`
             );
+            await this.storages[nodeName].init();
           }
           return this.storages[nodeName];
         }
@@ -22657,8 +21696,8 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
           const endDate = new Date(startDate);
           endDate.setDate(endDate.getDate() + daysToFetch - 1);
           return {
-            startDate: EnvironmentAdapter2.formatDate(startDate, "UTC", "yyyy-MM-dd"),
-            endDate: EnvironmentAdapter2.formatDate(endDate, "UTC", "yyyy-MM-dd")
+            startDate: DateUtils2.formatDate(startDate),
+            endDate: DateUtils2.formatDate(endDate)
           };
         }
       };
@@ -22704,7 +21743,6 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
       "BankOfCanada"
     ];
     const AvailableStorages = [
-      "GoogleSheets",
       "GoogleBigQuery",
       "AwsAthena"
     ];
@@ -22729,7 +21767,6 @@ API Response: ${JSON.stringify(statusResult, null, 2)}`);
       CriteoAds,
       BankOfCanada,
       // Individual storages
-      GoogleSheets,
       GoogleBigQuery,
       AwsAthena
     };