@owox/connectors 0.16.0-next-20251217153437 → 0.16.0-next-20251218103137

package/dist/connector-runner.cjs

@@ -17,6 +17,12 @@ const {
   ListObjectsV2Command,
   ListBucketsCommand
 } = require("@aws-sdk/client-s3");
+const {
+  RedshiftDataClient,
+  ExecuteStatementCommand,
+  DescribeStatementCommand,
+  GetStatementResultCommand
+} = require("@aws-sdk/client-redshift-data");
 const { Upload } = require("@aws-sdk/lib-storage");
 global.OWOX = OWOX;
 global.AdmZip = AdmZip;
@@ -31,6 +37,10 @@ global.S3Client = S3Client;
 global.DeleteObjectsCommand = DeleteObjectsCommand;
 global.ListObjectsV2Command = ListObjectsV2Command;
 global.ListBucketsCommand = ListBucketsCommand;
+global.RedshiftDataClient = RedshiftDataClient;
+global.ExecuteStatementCommand = ExecuteStatementCommand;
+global.DescribeStatementCommand = DescribeStatementCommand;
+global.GetStatementResultCommand = GetStatementResultCommand;
 global.Upload = Upload;
 const { Core, Connectors, Storages } = OWOX;
 Object.keys(Core).forEach((key) => {

package/dist/connector-runner.js

@@ -16,6 +16,12 @@ const {
   ListObjectsV2Command,
   ListBucketsCommand
 } = require("@aws-sdk/client-s3");
+const {
+  RedshiftDataClient,
+  ExecuteStatementCommand,
+  DescribeStatementCommand,
+  GetStatementResultCommand
+} = require("@aws-sdk/client-redshift-data");
 const { Upload } = require("@aws-sdk/lib-storage");
 global.OWOX = OWOX;
 global.AdmZip = AdmZip;
@@ -30,6 +36,10 @@ global.S3Client = S3Client;
 global.DeleteObjectsCommand = DeleteObjectsCommand;
 global.ListObjectsV2Command = ListObjectsV2Command;
 global.ListBucketsCommand = ListBucketsCommand;
+global.RedshiftDataClient = RedshiftDataClient;
+global.ExecuteStatementCommand = ExecuteStatementCommand;
+global.DescribeStatementCommand = DescribeStatementCommand;
+global.GetStatementResultCommand = GetStatementResultCommand;
 global.Upload = Upload;
 const { Core, Connectors, Storages } = OWOX;
 Object.keys(Core).forEach((key) => {

package/dist/index.cjs

@@ -1679,6 +1679,8 @@ class StorageConfigDto {
       return "AwsAthena";
     } else if (name === "SNOWFLAKE") {
       return "Snowflake";
+    } else if (name === "AWS_REDSHIFT") {
+      return "AwsRedshift";
     }
     return name;
   }
@@ -3015,6 +3017,439 @@ OPTIONS(description="${this.description}")`;
     manifest
   };
 })();
+const AwsRedshift = (function() {
+  const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, OauthFlowException: OauthFlowException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource3, AbstractRunConfig: AbstractRunConfig3, AbstractConnector: AbstractConnector3, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils3, FileUtils: FileUtils3, DateUtils: DateUtils3, CryptoUtils: CryptoUtils3, AsyncUtils: AsyncUtils3, RunConfigDto: RunConfigDto2, OauthCredentialsDto: OauthCredentialsDto2, OauthCredentialsDtoBuilder: OauthCredentialsDtoBuilder2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2, OAUTH_CONSTANTS: OAUTH_CONSTANTS2, OAUTH_SOURCE_CREDENTIALS_KEY: OAUTH_SOURCE_CREDENTIALS_KEY2 } = Core;
+  var AwsRedshiftStorage = class AwsRedshiftStorage extends AbstractStorage2 {
+    //---- constructor -------------------------------------------------
+    /**
+     * Class for managing data in AWS Redshift using Data API
+     *
+     * @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: "string", description: "smth" } }
+     * @param description (string) string with storage description
+     */
+    constructor(config, uniqueKeyColumns, schema = null, description = null) {
+      super(
+        config.mergeParameters({
+          AWSRegion: {
+            isRequired: true,
+            requiredType: "string"
+          },
+          AWSAccessKeyId: {
+            isRequired: true,
+            requiredType: "string"
+          },
+          AWSSecretAccessKey: {
+            isRequired: true,
+            requiredType: "string"
+          },
+          Database: {
+            isRequired: true,
+            requiredType: "string"
+          },
+          WorkgroupName: {
+            isRequired: false,
+            requiredType: "string"
+          },
+          ClusterIdentifier: {
+            isRequired: false,
+            requiredType: "string"
+          },
+          Schema: {
+            isRequired: true,
+            requiredType: "string"
+          },
+          DestinationTableName: {
+            isRequired: true,
+            requiredType: "string"
+          },
+          MaxBufferSize: {
+            isRequired: true,
+            default: 250
+          }
+        }),
+        uniqueKeyColumns,
+        schema,
+        description
+      );
+      this.initAWS();
+      this.updatedRecordsBuffer = {};
+      this.existingColumns = {};
+    }
+    //---- init --------------------------------------------------------
+    /**
+     * Initializing storage
+     */
+    async init() {
+      await this.checkConnection();
+      this.config.logMessage("Connection to Redshift established");
+    }
+    //----------------------------------------------------------------
+    //---- initAWS ----------------------------------------------------
+    /**
+     * Initialize AWS SDK clients
+     */
+    initAWS() {
+      try {
+        const clientConfig = {
+          region: this.config.AWSRegion.value,
+          credentials: {
+            accessKeyId: this.config.AWSAccessKeyId.value,
+            secretAccessKey: this.config.AWSSecretAccessKey.value
+          }
+        };
+        this.redshiftDataClient = new RedshiftDataClient(clientConfig);
+        this.config.logMessage("AWS SDK initialized successfully");
+      } catch (error) {
+        throw new Error(`Failed to initialize AWS SDK: ${error.message}`);
+      }
+    }
+    //----------------------------------------------------------------
+    //---- checkConnection ---------------------------------------------
+    /**
+     * Check connection to Redshift
+     * @returns {Promise}
+     */
+    async checkConnection() {
+      const params = {
+        Sql: "SELECT 1",
+        Database: this.config.Database.value
+      };
+      if (this.config.WorkgroupName.value) {
+        params.WorkgroupName = this.config.WorkgroupName.value;
+      } else if (this.config.ClusterIdentifier.value) {
+        params.ClusterIdentifier = this.config.ClusterIdentifier.value;
+      } else {
+        throw new Error("Either WorkgroupName or ClusterIdentifier must be provided");
+      }
+      try {
+        const command = new ExecuteStatementCommand(params);
+        const response = await this.redshiftDataClient.send(command);
+        await this.waitForQueryCompletion(response.Id);
+        return true;
+      } catch (error) {
+        throw new Error(`Connection check failed: ${error.message}`);
+      }
+    }
+    //----------------------------------------------------------------
+    //---- executeQuery -----------------------------------------------
+    /**
+     * Execute SQL query using Redshift Data API
+     * @param {string} sql - SQL query to execute
+     * @param {string} type - Query type ('ddl' or 'dml')
+     * @returns {Promise}
+     */
+    async executeQuery(sql, type = "dml") {
+      const params = {
+        Sql: sql,
+        Database: this.config.Database.value
+      };
+      if (this.config.WorkgroupName.value) {
+        params.WorkgroupName = this.config.WorkgroupName.value;
+      } else if (this.config.ClusterIdentifier.value) {
+        params.ClusterIdentifier = this.config.ClusterIdentifier.value;
+      }
+      try {
+        const command = new ExecuteStatementCommand(params);
+        const response = await this.redshiftDataClient.send(command);
+        await this.waitForQueryCompletion(response.Id);
+        return response.Id;
+      } catch (error) {
+        this.config.logMessage(`Query execution failed: ${error.message}`, "error");
+        throw error;
+      }
+    }
+    //----------------------------------------------------------------
+    //---- waitForQueryCompletion -------------------------------------
+    /**
+     * Wait for query execution to complete
+     * @param {string} statementId - Statement ID to check
+     * @returns {Promise}
+     */
+    async waitForQueryCompletion(statementId) {
+      const maxAttempts = 300;
+      let attempts = 0;
+      while (attempts < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        const describeCommand = new DescribeStatementCommand({ Id: statementId });
+        const response = await this.redshiftDataClient.send(describeCommand);
+        const status = response.Status;
+        if (status === "FINISHED") {
+          return;
+        } else if (status === "FAILED" || status === "ABORTED") {
+          const error = response.Error || "Unknown error";
+          throw new Error(`Query ${status}: ${error}`);
+        }
+        attempts++;
+      }
+      throw new Error(`Query timeout after ${maxAttempts} seconds for statement ${statementId}`);
+    }
+    //----------------------------------------------------------------
+    //---- getColumnType ----------------------------------------------
+    /**
+     * Get Redshift column type for a field
+     * @param {string} columnName - Column name
+     * @returns {string} - Redshift column type
+     */
+    getColumnType(columnName) {
+      const field = this.schema[columnName];
+      if (!field) {
+        return "VARCHAR(65535)";
+      }
+      if (field.RedshiftType) {
+        return field.RedshiftType;
+      }
+      const type = field.type ? field.type.toLowerCase() : "string";
+      switch (type) {
+        case "integer":
+        case "int":
+          return "BIGINT";
+        case "float":
+        case "number":
+          return "DOUBLE PRECISION";
+        case "boolean":
+        case "bool":
+          return "BOOLEAN";
+        case "date":
+          return "DATE";
+        case "datetime":
+        case "timestamp":
+          return "TIMESTAMP";
+        case "json":
+          return "SUPER";
+        default:
+          return "VARCHAR(65535)";
+      }
+    }
+    //----------------------------------------------------------------
+    //---- createSchemaIfNotExist -------------------------------------
+    /**
+     * Create schema in Redshift if it doesn't exist
+     * @returns {Promise}
+     */
+    async createSchemaIfNotExist() {
+      const schemaName = this.config.Schema.value;
+      if (!schemaName) {
+        throw new Error("Schema name is required but not provided");
+      }
+      const createSchemaQuery = `CREATE SCHEMA IF NOT EXISTS "${schemaName}"`;
+      await this.executeQuery(createSchemaQuery, "ddl");
+      this.config.logMessage(`Schema "${schemaName}" ensured`);
+    }
+    //----------------------------------------------------------------
+    //---- createTable ------------------------------------------------
+    /**
+     * Create table in Redshift
+     * @returns {Promise}
+     */
+    async createTable() {
+      await this.createSchemaIfNotExist();
+      const existingColumns = {};
+      const columnDefinitions = [];
+      for (let columnName of this.uniqueKeyColumns) {
+        let columnType = this.getColumnType(columnName);
+        columnDefinitions.push(`"${columnName}" ${columnType}`);
+        existingColumns[columnName] = columnType;
+      }
+      let selectedFields = this.getSelectedFields();
+      for (let columnName in this.schema) {
+        if (!this.uniqueKeyColumns.includes(columnName) && selectedFields.includes(columnName)) {
+          let columnType = this.getColumnType(columnName);
+          columnDefinitions.push(`"${columnName}" ${columnType}`);
+          existingColumns[columnName] = columnType;
+        }
+      }
+      const pkColumns = this.uniqueKeyColumns.map((col) => `"${col}"`).join(", ");
+      const query = `
+        CREATE TABLE IF NOT EXISTS "${this.config.Schema.value}"."${this.config.DestinationTableName.value}" (
+          ${columnDefinitions.join(",\n        ")},
+          PRIMARY KEY (${pkColumns})
+        )
+      `;
+      await this.executeQuery(query, "ddl");
+      this.config.logMessage(`Table "${this.config.Schema.value}"."${this.config.DestinationTableName.value}" created`);
+      this.existingColumns = existingColumns;
+      return existingColumns;
+    }
+    //----------------------------------------------------------------
+    //---- addNewColumns ----------------------------------------------
+    /**
+     * Add new columns to the Redshift table
+     * @param {Array} newColumns - Array of column names to add
+     * @returns {Promise}
+     */
+    async addNewColumns(newColumns) {
+      const columnsToAdd = [];
+      for (let columnName of newColumns) {
+        if (columnName in this.schema) {
+          let columnType = this.getColumnType(columnName);
+          columnsToAdd.push(`"${columnName}" ${columnType}`);
+          this.existingColumns[columnName] = columnType;
+        }
+      }
+      if (columnsToAdd.length > 0) {
+        const query = `
+          ALTER TABLE "${this.config.Schema.value}"."${this.config.DestinationTableName.value}"
+          ADD COLUMN ${columnsToAdd.join(", ADD COLUMN ")}
+        `;
+        await this.executeQuery(query, "ddl");
+        this.config.logMessage(`Columns '${newColumns.join(",")}' were added to "${this.config.Schema.value}"."${this.config.DestinationTableName.value}" table`);
+        return newColumns;
+      }
+      return newColumns;
+    }
+    //----------------------------------------------------------------
+    //---- saveData ---------------------------------------------------
+    /**
+     * Saving data to Redshift using MERGE
+     * @param {Array} data - Array of objects with records to save
+     * @returns {Promise}
+     */
+    async saveData(data) {
+      if (!data || data.length === 0) {
+        return Promise.resolve();
+      }
+      if (Object.keys(this.existingColumns).length === 0) {
+        await this.createTable();
+      }
+      const dataKeys = Object.keys(data[0]);
+      const newColumns = dataKeys.filter((key) => !(key in this.existingColumns));
+      if (newColumns.length > 0) {
+        await this.addNewColumns(newColumns);
+      }
+      const selectedFields = this.getSelectedFields();
+      const columnsToInsert = dataKeys.filter((key) => selectedFields.includes(key));
+      const tempTableName = `temp_${this.config.DestinationTableName.value}_${Date.now()}`;
+      const schemaName = this.config.Schema.value;
+      if (!schemaName) {
+        throw new Error("Schema name is required but not provided");
+      }
+      const tempColumns = columnsToInsert.map(
+        (col) => `"${col}" ${this.existingColumns[col] || this.getColumnType(col)}`
+      ).join(", ");
+      await this.executeQuery(`
+        CREATE TABLE "${schemaName}"."${tempTableName}" (${tempColumns})
+      `, "ddl");
+      try {
+        const batchSize = this.config.MaxBufferSize.value;
+        for (let i = 0; i < data.length; i += batchSize) {
+          const batch = data.slice(i, i + batchSize);
+          await this.insertBatch(tempTableName, columnsToInsert, batch);
+        }
+        await this.mergeTempTable(tempTableName, columnsToInsert);
+      } finally {
+        try {
+          await this.executeQuery(`DROP TABLE "${schemaName}"."${tempTableName}"`, "ddl");
+          this.config.logMessage(`Temp table "${tempTableName}" cleaned up`);
+        } catch (dropError) {
+          this.config.logMessage(`Warning: Failed to drop temp table "${tempTableName}": ${dropError.message}`);
+        }
+      }
+      this.config.logMessage(`Successfully saved ${data.length} records`);
+      return data.length;
+    }
+    //----------------------------------------------------------------
+    //---- insertBatch ------------------------------------------------
+    /**
+     * Insert batch of records into temp table
+     * @param {string} tableName - Table name
+     * @param {Array} columns - Column names
+     * @param {Array} records - Records to insert
+     * @returns {Promise}
+     */
+    async insertBatch(tableName, columns, records) {
+      const values = records.map((record) => {
+        const vals = columns.map((col) => {
+          const value = record[col];
+          if (value === null || value === void 0) {
+            return "NULL";
+          }
+          if (typeof value === "boolean") {
+            return value ? "TRUE" : "FALSE";
+          }
+          if (typeof value === "number") {
+            if (isNaN(value) || !isFinite(value)) {
+              return "NULL";
+            }
+            return value;
+          }
+          const stringValue = String(value).replace(/'/g, "''");
+          return `'${stringValue}'`;
+        }).join(", ");
+        return `(${vals})`;
+      }).join(",\n      ");
+      const columnList = columns.map((col) => `"${col}"`).join(", ");
+      const query = `
+        INSERT INTO "${this.config.Schema.value}"."${tableName}" (${columnList})
+        VALUES ${values}
+      `;
+      await this.executeQuery(query, "dml");
+    }
+    //----------------------------------------------------------------
+    //---- mergeTempTable ---------------------------------------------
+    /**
+     * Merge temp table data into main table
+     * @param {string} tempTableName - Temp table name
+     * @param {Array} columns - Column names
+     * @returns {Promise}
+     */
+    async mergeTempTable(tempTableName, columns) {
+      const targetTable = `"${this.config.Schema.value}"."${this.config.DestinationTableName.value}"`;
+      const sourceTable = `"${this.config.Schema.value}"."${tempTableName}"`;
+      const onClause = this.uniqueKeyColumns.map(
+        (col) => `${targetTable}."${col}" = ${sourceTable}."${col}"`
+      ).join(" AND ");
+      const updateColumns = columns.filter((col) => !this.uniqueKeyColumns.includes(col));
+      const updateSet = updateColumns.map(
+        (col) => `"${col}" = ${sourceTable}."${col}"`
+      ).join(", ");
+      const insertColumns = columns.map((col) => `"${col}"`).join(", ");
+      const insertValues = columns.map((col) => `${sourceTable}."${col}"`).join(", ");
+      const query = `
+        MERGE INTO ${targetTable}
+        USING ${sourceTable}
+        ON ${onClause}
+        WHEN MATCHED THEN
+          UPDATE SET ${updateSet}
+        WHEN NOT MATCHED THEN
+          INSERT (${insertColumns})
+          VALUES (${insertValues})
+      `;
+      await this.executeQuery(query, "dml");
+    }
+    //----------------------------------------------------------------
+  };
+  const manifest = {
+    "name": "AwsRedshiftStorage",
+    "description": "Storage for AWS Redshift using Data API with support for Serverless and Provisioned clusters",
+    "title": "AWS Redshift",
+    "version": "1.0.0",
+    "author": "OWOX, Inc.",
+    "license": "MIT",
+    "environment": {
+      "node": {
+        "enabled": true,
+        "dependencies": [
+          {
+            "name": "@aws-sdk/client-redshift-data",
+            "version": "3.952.0",
+            "global": [
+              "RedshiftDataClient",
+              "ExecuteStatementCommand",
+              "DescribeStatementCommand",
+              "GetStatementResultCommand"
+            ]
+          }
+        ]
+      }
+    }
+  };
+  return {
+    AwsRedshiftStorage,
+    manifest
+  };
+})();
 const AwsAthena = (function() {
   const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, OauthFlowException: OauthFlowException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource3, AbstractRunConfig: AbstractRunConfig3, AbstractConnector: AbstractConnector3, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils3, FileUtils: FileUtils3, DateUtils: DateUtils3, CryptoUtils: CryptoUtils3, AsyncUtils: AsyncUtils3, RunConfigDto: RunConfigDto2, OauthCredentialsDto: OauthCredentialsDto2, OauthCredentialsDtoBuilder: OauthCredentialsDtoBuilder2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2, OAUTH_CONSTANTS: OAUTH_CONSTANTS2, OAUTH_SOURCE_CREDENTIALS_KEY: OAUTH_SOURCE_CREDENTIALS_KEY2 } = Core;
   var AwsAthenaStorage = class AwsAthenaStorage extends AbstractStorage2 {
@@ -3656,6 +4091,7 @@ const AwsAthena = (function() {
 const Storages = {
   Snowflake,
   GoogleBigQuery,
+  AwsRedshift,
   AwsAthena
 };
 const XAds = (function() {
@@ -24581,6 +25017,7 @@ const AvailableConnectors = [
 const AvailableStorages = [
   "Snowflake",
   "GoogleBigQuery",
+  "AwsRedshift",
   "AwsAthena"
 ];
 const OWOX = {
@@ -24607,6 +25044,7 @@ const OWOX = {
   // Individual storages
   Snowflake,
   GoogleBigQuery,
+  AwsRedshift,
   AwsAthena
 };
 if (typeof module !== "undefined" && module.exports) {

package/dist/index.js

@@ -1677,6 +1677,8 @@ class StorageConfigDto {
       return "AwsAthena";
     } else if (name === "SNOWFLAKE") {
       return "Snowflake";
+    } else if (name === "AWS_REDSHIFT") {
+      return "AwsRedshift";
     }
     return name;
   }
@@ -3013,6 +3015,439 @@ OPTIONS(description="${this.description}")`;
     manifest
   };
 })();
+const AwsRedshift = (function() {
+  const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, OauthFlowException: OauthFlowException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource3, AbstractRunConfig: AbstractRunConfig3, AbstractConnector: AbstractConnector3, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils3, FileUtils: FileUtils3, DateUtils: DateUtils3, CryptoUtils: CryptoUtils3, AsyncUtils: AsyncUtils3, RunConfigDto: RunConfigDto2, OauthCredentialsDto: OauthCredentialsDto2, OauthCredentialsDtoBuilder: OauthCredentialsDtoBuilder2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2, OAUTH_CONSTANTS: OAUTH_CONSTANTS2, OAUTH_SOURCE_CREDENTIALS_KEY: OAUTH_SOURCE_CREDENTIALS_KEY2 } = Core;
+  var AwsRedshiftStorage = class AwsRedshiftStorage extends AbstractStorage2 {
+    //---- constructor -------------------------------------------------
+    /**
+     * Class for managing data in AWS Redshift using Data API
+     *
+     * @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: "string", description: "smth" } }
+     * @param description (string) string with storage description
+     */
+    constructor(config, uniqueKeyColumns, schema = null, description = null) {
+      super(
+        config.mergeParameters({
+          AWSRegion: {
+            isRequired: true,
+            requiredType: "string"
+          },
+          AWSAccessKeyId: {
+            isRequired: true,
+            requiredType: "string"
+          },
+          AWSSecretAccessKey: {
+            isRequired: true,
+            requiredType: "string"
+          },
+          Database: {
+            isRequired: true,
+            requiredType: "string"
+          },
+          WorkgroupName: {
+            isRequired: false,
+            requiredType: "string"
+          },
+          ClusterIdentifier: {
+            isRequired: false,
+            requiredType: "string"
+          },
+          Schema: {
+            isRequired: true,
+            requiredType: "string"
+          },
+          DestinationTableName: {
+            isRequired: true,
+            requiredType: "string"
+          },
+          MaxBufferSize: {
+            isRequired: true,
+            default: 250
+          }
+        }),
+        uniqueKeyColumns,
+        schema,
+        description
+      );
+      this.initAWS();
+      this.updatedRecordsBuffer = {};
+      this.existingColumns = {};
+    }
+    //---- init --------------------------------------------------------
+    /**
+     * Initializing storage
+     */
+    async init() {
+      await this.checkConnection();
+      this.config.logMessage("Connection to Redshift established");
+    }
+    //----------------------------------------------------------------
+    //---- initAWS ----------------------------------------------------
+    /**
+     * Initialize AWS SDK clients
+     */
+    initAWS() {
+      try {
+        const clientConfig = {
+          region: this.config.AWSRegion.value,
+          credentials: {
+            accessKeyId: this.config.AWSAccessKeyId.value,
+            secretAccessKey: this.config.AWSSecretAccessKey.value
+          }
+        };
+        this.redshiftDataClient = new RedshiftDataClient(clientConfig);
+        this.config.logMessage("AWS SDK initialized successfully");
+      } catch (error) {
+        throw new Error(`Failed to initialize AWS SDK: ${error.message}`);
+      }
+    }
+    //----------------------------------------------------------------
+    //---- checkConnection ---------------------------------------------
+    /**
+     * Check connection to Redshift
+     * @returns {Promise}
+     */
+    async checkConnection() {
+      const params = {
+        Sql: "SELECT 1",
+        Database: this.config.Database.value
+      };
+      if (this.config.WorkgroupName.value) {
+        params.WorkgroupName = this.config.WorkgroupName.value;
+      } else if (this.config.ClusterIdentifier.value) {
+        params.ClusterIdentifier = this.config.ClusterIdentifier.value;
+      } else {
+        throw new Error("Either WorkgroupName or ClusterIdentifier must be provided");
+      }
+      try {
+        const command = new ExecuteStatementCommand(params);
+        const response = await this.redshiftDataClient.send(command);
+        await this.waitForQueryCompletion(response.Id);
+        return true;
+      } catch (error) {
+        throw new Error(`Connection check failed: ${error.message}`);
+      }
+    }
+    //----------------------------------------------------------------
+    //---- executeQuery -----------------------------------------------
+    /**
+     * Execute SQL query using Redshift Data API
+     * @param {string} sql - SQL query to execute
+     * @param {string} type - Query type ('ddl' or 'dml')
+     * @returns {Promise}
+     */
+    async executeQuery(sql, type = "dml") {
+      const params = {
+        Sql: sql,
+        Database: this.config.Database.value
+      };
+      if (this.config.WorkgroupName.value) {
+        params.WorkgroupName = this.config.WorkgroupName.value;
+      } else if (this.config.ClusterIdentifier.value) {
+        params.ClusterIdentifier = this.config.ClusterIdentifier.value;
+      }
+      try {
+        const command = new ExecuteStatementCommand(params);
+        const response = await this.redshiftDataClient.send(command);
+        await this.waitForQueryCompletion(response.Id);
+        return response.Id;
+      } catch (error) {
+        this.config.logMessage(`Query execution failed: ${error.message}`, "error");
+        throw error;
+      }
+    }
+    //----------------------------------------------------------------
+    //---- waitForQueryCompletion -------------------------------------
+    /**
+     * Wait for query execution to complete
+     * @param {string} statementId - Statement ID to check
+     * @returns {Promise}
+     */
+    async waitForQueryCompletion(statementId) {
+      const maxAttempts = 300;
+      let attempts = 0;
+      while (attempts < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        const describeCommand = new DescribeStatementCommand({ Id: statementId });
+        const response = await this.redshiftDataClient.send(describeCommand);
+        const status = response.Status;
+        if (status === "FINISHED") {
+          return;
+        } else if (status === "FAILED" || status === "ABORTED") {
+          const error = response.Error || "Unknown error";
+          throw new Error(`Query ${status}: ${error}`);
+        }
+        attempts++;
+      }
+      throw new Error(`Query timeout after ${maxAttempts} seconds for statement ${statementId}`);
+    }
+    //----------------------------------------------------------------
+    //---- getColumnType ----------------------------------------------
+    /**
+     * Get Redshift column type for a field
+     * @param {string} columnName - Column name
+     * @returns {string} - Redshift column type
+     */
+    getColumnType(columnName) {
+      const field = this.schema[columnName];
+      if (!field) {
+        return "VARCHAR(65535)";
+      }
+      if (field.RedshiftType) {
+        return field.RedshiftType;
+      }
+      const type = field.type ? field.type.toLowerCase() : "string";
+      switch (type) {
+        case "integer":
+        case "int":
+          return "BIGINT";
+        case "float":
+        case "number":
+          return "DOUBLE PRECISION";
+        case "boolean":
+        case "bool":
+          return "BOOLEAN";
+        case "date":
+          return "DATE";
+        case "datetime":
+        case "timestamp":
+          return "TIMESTAMP";
+        case "json":
+          return "SUPER";
+        default:
+          return "VARCHAR(65535)";
+      }
+    }
+    //----------------------------------------------------------------
+    //---- createSchemaIfNotExist -------------------------------------
+    /**
+     * Create schema in Redshift if it doesn't exist
+     * @returns {Promise}
+     */
+    async createSchemaIfNotExist() {
+      const schemaName = this.config.Schema.value;
+      if (!schemaName) {
+        throw new Error("Schema name is required but not provided");
+      }
+      const createSchemaQuery = `CREATE SCHEMA IF NOT EXISTS "${schemaName}"`;
+      await this.executeQuery(createSchemaQuery, "ddl");
+      this.config.logMessage(`Schema "${schemaName}" ensured`);
+    }
+    //----------------------------------------------------------------
+    //---- createTable ------------------------------------------------
+    /**
+     * Create table in Redshift
+     * @returns {Promise}
+     */
+    async createTable() {
+      await this.createSchemaIfNotExist();
+      const existingColumns = {};
+      const columnDefinitions = [];
+      for (let columnName of this.uniqueKeyColumns) {
+        let columnType = this.getColumnType(columnName);
+        columnDefinitions.push(`"${columnName}" ${columnType}`);
+        existingColumns[columnName] = columnType;
+      }
+      let selectedFields = this.getSelectedFields();
+      for (let columnName in this.schema) {
+        if (!this.uniqueKeyColumns.includes(columnName) && selectedFields.includes(columnName)) {
+          let columnType = this.getColumnType(columnName);
+          columnDefinitions.push(`"${columnName}" ${columnType}`);
+          existingColumns[columnName] = columnType;
+        }
+      }
+      const pkColumns = this.uniqueKeyColumns.map((col) => `"${col}"`).join(", ");
+      const query = `
+        CREATE TABLE IF NOT EXISTS "${this.config.Schema.value}"."${this.config.DestinationTableName.value}" (
+          ${columnDefinitions.join(",\n        ")},
+          PRIMARY KEY (${pkColumns})
+        )
+      `;
+      await this.executeQuery(query, "ddl");
+      this.config.logMessage(`Table "${this.config.Schema.value}"."${this.config.DestinationTableName.value}" created`);
+      this.existingColumns = existingColumns;
+      return existingColumns;
+    }
+    //----------------------------------------------------------------
+    //---- addNewColumns ----------------------------------------------
+    /**
+     * Add new columns to the Redshift table
+     * @param {Array} newColumns - Array of column names to add
+     * @returns {Promise}
+     */
+    async addNewColumns(newColumns) {
+      const columnsToAdd = [];
+      for (let columnName of newColumns) {
+        if (columnName in this.schema) {
+          let columnType = this.getColumnType(columnName);
+          columnsToAdd.push(`"${columnName}" ${columnType}`);
+          this.existingColumns[columnName] = columnType;
+        }
+      }
+      if (columnsToAdd.length > 0) {
+        const query = `
+          ALTER TABLE "${this.config.Schema.value}"."${this.config.DestinationTableName.value}"
+          ADD COLUMN ${columnsToAdd.join(", ADD COLUMN ")}
+        `;
+        await this.executeQuery(query, "ddl");
+        this.config.logMessage(`Columns '${newColumns.join(",")}' were added to "${this.config.Schema.value}"."${this.config.DestinationTableName.value}" table`);
+        return newColumns;
+      }
+      return newColumns;
+    }
+    //----------------------------------------------------------------
+    //---- saveData ---------------------------------------------------
+    /**
+     * Saving data to Redshift using MERGE
+     * @param {Array} data - Array of objects with records to save
+     * @returns {Promise}
+     */
+    async saveData(data) {
+      if (!data || data.length === 0) {
+        return Promise.resolve();
+      }
+      if (Object.keys(this.existingColumns).length === 0) {
+        await this.createTable();
+      }
+      const dataKeys = Object.keys(data[0]);
+      const newColumns = dataKeys.filter((key) => !(key in this.existingColumns));
+      if (newColumns.length > 0) {
+        await this.addNewColumns(newColumns);
+      }
+      const selectedFields = this.getSelectedFields();
+      const columnsToInsert = dataKeys.filter((key) => selectedFields.includes(key));
+      const tempTableName = `temp_${this.config.DestinationTableName.value}_${Date.now()}`;
+      const schemaName = this.config.Schema.value;
+      if (!schemaName) {
+        throw new Error("Schema name is required but not provided");
+      }
+      const tempColumns = columnsToInsert.map(
+        (col) => `"${col}" ${this.existingColumns[col] || this.getColumnType(col)}`
+      ).join(", ");
+      await this.executeQuery(`
+        CREATE TABLE "${schemaName}"."${tempTableName}" (${tempColumns})
+      `, "ddl");
+      try {
+        const batchSize = this.config.MaxBufferSize.value;
+        for (let i = 0; i < data.length; i += batchSize) {
+          const batch = data.slice(i, i + batchSize);
+          await this.insertBatch(tempTableName, columnsToInsert, batch);
+        }
+        await this.mergeTempTable(tempTableName, columnsToInsert);
+      } finally {
+        try {
+          await this.executeQuery(`DROP TABLE "${schemaName}"."${tempTableName}"`, "ddl");
+          this.config.logMessage(`Temp table "${tempTableName}" cleaned up`);
+        } catch (dropError) {
+          this.config.logMessage(`Warning: Failed to drop temp table "${tempTableName}": ${dropError.message}`);
+        }
+      }
+      this.config.logMessage(`Successfully saved ${data.length} records`);
+      return data.length;
+    }
+    //----------------------------------------------------------------
+    //---- insertBatch ------------------------------------------------
+    /**
+     * Insert batch of records into temp table
+     * @param {string} tableName - Table name
+     * @param {Array} columns - Column names
+     * @param {Array} records - Records to insert
+     * @returns {Promise}
+     */
+    async insertBatch(tableName, columns, records) {
+      const values = records.map((record) => {
+        const vals = columns.map((col) => {
+          const value = record[col];
+          if (value === null || value === void 0) {
+            return "NULL";
+          }
+          if (typeof value === "boolean") {
+            return value ? "TRUE" : "FALSE";
+          }
+          if (typeof value === "number") {
+            if (isNaN(value) || !isFinite(value)) {
+              return "NULL";
+            }
+            return value;
+          }
+          const stringValue = String(value).replace(/'/g, "''");
+          return `'${stringValue}'`;
+        }).join(", ");
+        return `(${vals})`;
+      }).join(",\n      ");
+      const columnList = columns.map((col) => `"${col}"`).join(", ");
+      const query = `
+        INSERT INTO "${this.config.Schema.value}"."${tableName}" (${columnList})
+        VALUES ${values}
+      `;
+      await this.executeQuery(query, "dml");
+    }
+    //----------------------------------------------------------------
+    //---- mergeTempTable ---------------------------------------------
+    /**
+     * Merge temp table data into main table
+     * @param {string} tempTableName - Temp table name
+     * @param {Array} columns - Column names
+     * @returns {Promise}
+     */
+    async mergeTempTable(tempTableName, columns) {
+      const targetTable = `"${this.config.Schema.value}"."${this.config.DestinationTableName.value}"`;
+      const sourceTable = `"${this.config.Schema.value}"."${tempTableName}"`;
+      const onClause = this.uniqueKeyColumns.map(
+        (col) => `${targetTable}."${col}" = ${sourceTable}."${col}"`
+      ).join(" AND ");
+      const updateColumns = columns.filter((col) => !this.uniqueKeyColumns.includes(col));
+      const updateSet = updateColumns.map(
+        (col) => `"${col}" = ${sourceTable}."${col}"`
+      ).join(", ");
+      const insertColumns = columns.map((col) => `"${col}"`).join(", ");
+      const insertValues = columns.map((col) => `${sourceTable}."${col}"`).join(", ");
+      const query = `
+        MERGE INTO ${targetTable}
+        USING ${sourceTable}
+        ON ${onClause}
+        WHEN MATCHED THEN
+          UPDATE SET ${updateSet}
+        WHEN NOT MATCHED THEN
+          INSERT (${insertColumns})
+          VALUES (${insertValues})
+      `;
+      await this.executeQuery(query, "dml");
+    }
+    //----------------------------------------------------------------
+  };
+  const manifest = {
+    "name": "AwsRedshiftStorage",
+    "description": "Storage for AWS Redshift using Data API with support for Serverless and Provisioned clusters",
+    "title": "AWS Redshift",
+    "version": "1.0.0",
+    "author": "OWOX, Inc.",
+    "license": "MIT",
+    "environment": {
+      "node": {
+        "enabled": true,
+        "dependencies": [
+          {
+            "name": "@aws-sdk/client-redshift-data",
+            "version": "3.952.0",
+            "global": [
+              "RedshiftDataClient",
+              "ExecuteStatementCommand",
+              "DescribeStatementCommand",
+              "GetStatementResultCommand"
+            ]
+          }
+        ]
+      }
+    }
+  };
+  return {
+    AwsRedshiftStorage,
+    manifest
+  };
+})();
 const AwsAthena = (function() {
   const { AbstractException: AbstractException2, HttpRequestException: HttpRequestException2, OauthFlowException: OauthFlowException2, AbstractStorage: AbstractStorage2, AbstractSource: AbstractSource3, AbstractRunConfig: AbstractRunConfig3, AbstractConnector: AbstractConnector3, AbstractConfig: AbstractConfig2, HttpUtils: HttpUtils3, FileUtils: FileUtils3, DateUtils: DateUtils3, CryptoUtils: CryptoUtils3, AsyncUtils: AsyncUtils3, RunConfigDto: RunConfigDto2, OauthCredentialsDto: OauthCredentialsDto2, OauthCredentialsDtoBuilder: OauthCredentialsDtoBuilder2, SourceConfigDto: SourceConfigDto2, StorageConfigDto: StorageConfigDto2, ConfigDto: ConfigDto2, HTTP_STATUS: HTTP_STATUS2, EXECUTION_STATUS: EXECUTION_STATUS2, RUN_CONFIG_TYPE: RUN_CONFIG_TYPE2, CONFIG_ATTRIBUTES: CONFIG_ATTRIBUTES2, OAUTH_CONSTANTS: OAUTH_CONSTANTS2, OAUTH_SOURCE_CREDENTIALS_KEY: OAUTH_SOURCE_CREDENTIALS_KEY2 } = Core;
   var AwsAthenaStorage = class AwsAthenaStorage extends AbstractStorage2 {
@@ -3654,6 +4089,7 @@ const AwsAthena = (function() {
 const Storages = {
   Snowflake,
   GoogleBigQuery,
+  AwsRedshift,
   AwsAthena
 };
 const XAds = (function() {
@@ -24579,6 +25015,7 @@ const AvailableConnectors = [
 const AvailableStorages = [
   "Snowflake",
   "GoogleBigQuery",
+  "AwsRedshift",
   "AwsAthena"
 ];
 const OWOX = {
@@ -24605,6 +25042,7 @@ const OWOX = {
   // Individual storages
   Snowflake,
   GoogleBigQuery,
+  AwsRedshift,
   AwsAthena
 };
 if (typeof module !== "undefined" && module.exports) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owox/connectors",
-  "version": "0.16.0-next-20251217153437",
+  "version": "0.16.0-next-20251218103137",
   "description": "Connectors and storages for different data sources",
   "license": "MIT",
   "publishConfig": {