@prismatic-io/components-aws-redshift 0.0.0-stage → 0.1.0

package/npm-dist/index.cjs

@@ -0,0 +1,1139 @@
+let _prismatic_io_spectral = require("@prismatic-io/spectral");
+let _aws_sdk_client_sts = require("@aws-sdk/client-sts");
+let _aws_sdk_client_redshift_data = require("@aws-sdk/client-redshift-data");
+let _prismatic_io_spectral_http = require("@prismatic-io/spectral/http");
+let aws4 = require("aws4");
+//#region ../../packages/aws-utils/dist/connection/assumeRole.js
+var __awaiter$3 = function(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+};
+const assumeRole = (region, accessKeyId, secretAccessKey, roleArn, externalId) => __awaiter$3(void 0, void 0, void 0, function* () {
+	const { Credentials: { AccessKeyId, SecretAccessKey, SessionToken } } = yield new _aws_sdk_client_sts.STSClient(Object.assign(Object.assign({}, region.length > 0 && { region }), { credentials: {
+		accessKeyId,
+		secretAccessKey
+	} })).send(new _aws_sdk_client_sts.AssumeRoleCommand({
+		RoleArn: _prismatic_io_spectral.util.types.toString(roleArn),
+		RoleSessionName: "integration-session",
+		ExternalId: externalId
+	}));
+	return {
+		accessKeyId: AccessKeyId,
+		secretAccessKey: SecretAccessKey,
+		sessionToken: SessionToken
+	};
+});
+//#endregion
+//#region ../../packages/aws-utils/dist/connection/assumeRoleConnection.js
+const assumeRoleConnection = {
+	key: "awsAssumeRole",
+	display: {
+		label: "AWS Role ARN",
+		description: "Connect to AWS using an assumed role"
+	},
+	inputs: {
+		roleARN: {
+			label: "Role ARN",
+			placeholder: "arn:aws:iam::OtherAccount-ID:role/assumed-role-name",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "An AWS IAM Role ARN",
+			example: "arn:aws:iam::OtherAccount-ID:role/assumed-role-name"
+		},
+		accessKeyId: {
+			label: "Access Key ID",
+			placeholder: "Access Key ID",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "An AWS IAM Access Key ID",
+			example: "AKIAIOSFODNN7EXAMPLE"
+		},
+		secretAccessKey: {
+			label: "Secret Access Key",
+			placeholder: "Secret Access Key",
+			type: "password",
+			required: true,
+			shown: true,
+			comments: "An AWS IAM Secret Access Key",
+			example: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
+		},
+		externalId: {
+			label: "External ID",
+			placeholder: "shared-common-secret",
+			type: "string",
+			required: false,
+			shown: true,
+			comments: "Provides enhanced security measures to the connection. Optional, but recommended. Please check [AWS docs](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html#id_roles_third-party_external-id) for more information.",
+			example: "shared-common-secret"
+		}
+	}
+};
+//#endregion
+//#region ../../packages/aws-utils/dist/helpers/misc.js
+const toTrimmedString = (value) => _prismatic_io_spectral.util.types.toString(value).trim();
+const toOptionalString$1 = (value) => value ? _prismatic_io_spectral.util.types.toString(value) : void 0;
+//#endregion
+//#region ../../packages/aws-utils/dist/helpers/getCredentials.js
+const getCredentials = (connection) => {
+	return {
+		accessKeyId: toTrimmedString(connection.fields.accessKeyId),
+		secretAccessKey: toTrimmedString(connection.fields.secretAccessKey)
+	};
+};
+//#endregion
+//#region ../../packages/aws-utils/dist/helpers/validateConnection.js
+const validateConnection$1 = (connection, validConnectionKeys) => {
+	if (![assumeRoleConnection.key, ...validConnectionKeys].includes(connection.key)) throw new _prismatic_io_spectral.ConnectionError(connection, `Unsupported connection method ${connection.key}.`);
+};
+//#endregion
+//#region ../../packages/aws-utils/dist/client/getClientParams.js
+var __awaiter$2 = function(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+};
+const getClientParams = (_a) => __awaiter$2(void 0, [_a], void 0, function* ({ awsRegion, awsConnection, validConnectionKeys, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) {
+	var _b;
+	let shouldAssumeRole = false;
+	if (awsConnection) {
+		validateConnection$1(awsConnection, validConnectionKeys);
+		if (dynamicAccessKeyId || dynamicSecretAccessKey) throw new Error("Please specify either a connection or dynamic access key and secret inputs.");
+		shouldAssumeRole = awsConnection.key === assumeRoleConnection.key;
+	}
+	if (!awsConnection && (!dynamicAccessKeyId || !dynamicSecretAccessKey)) throw new Error("You must specify either a connection input or dynamic access key and secret inputs.");
+	const { accessKeyId, secretAccessKey } = awsConnection ? getCredentials(awsConnection) : {
+		accessKeyId: dynamicAccessKeyId,
+		secretAccessKey: dynamicSecretAccessKey
+	};
+	const credentials = shouldAssumeRole ? yield assumeRole(awsRegion, accessKeyId, secretAccessKey, toTrimmedString(awsConnection.fields.roleARN), toOptionalString$1((_b = awsConnection.fields) === null || _b === void 0 ? void 0 : _b.externalId)) : {
+		accessKeyId,
+		secretAccessKey,
+		sessionToken: dynamicSessionToken
+	};
+	return {
+		region: awsRegion.length > 0 ? awsRegion : void 0,
+		credentials
+	};
+});
+//#endregion
+//#region ../../packages/aws-utils/dist/data/awsRegions.js
+const awsRegions = [
+	"af-south-1",
+	"ap-east-1",
+	"ap-east-2",
+	"ap-northeast-1",
+	"ap-northeast-2",
+	"ap-northeast-3",
+	"ap-south-1",
+	"ap-south-2",
+	"ap-southeast-1",
+	"ap-southeast-2",
+	"ap-southeast-3",
+	"ap-southeast-4",
+	"ap-southeast-5",
+	"ap-southeast-6",
+	"ap-southeast-7",
+	"ca-central-1",
+	"ca-west-1",
+	"eu-central-1",
+	"eu-central-2",
+	"eu-north-1",
+	"eu-south-1",
+	"eu-south-2",
+	"eu-west-1",
+	"eu-west-2",
+	"eu-west-3",
+	"il-central-1",
+	"me-central-1",
+	"me-south-1",
+	"mx-central-1",
+	"sa-east-1",
+	"us-east-1",
+	"us-east-2",
+	"us-gov-east-1",
+	"us-gov-west-1",
+	"us-west-1",
+	"us-west-2"
+];
+//#endregion
+//#region ../../packages/aws-utils/dist/dataSources/selectRegion.js
+var __awaiter$1 = function(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+};
+const selectRegion = (0, _prismatic_io_spectral.dataSource)({
+	display: {
+		label: "Select AWS Region",
+		description: "Select an AWS region"
+	},
+	dataSourceType: "picklist",
+	perform: () => __awaiter$1(void 0, void 0, void 0, function* () {
+		return Promise.resolve({ result: awsRegions.map((region) => ({
+			label: region,
+			key: region
+		})) });
+	}),
+	inputs: {}
+});
+//#endregion
+//#region ../../packages/aws-utils/dist/helpers/pagination.js
+var __awaiter = function(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+};
+const paginateAwsResults = (options) => __awaiter(void 0, void 0, void 0, function* () {
+	const { createCommand, client, itemsKey } = options;
+	const allItems = [];
+	let nextToken;
+	let lastResponse;
+	do {
+		const command = createCommand(nextToken);
+		const response = yield client.send(command);
+		lastResponse = response;
+		const record = response;
+		const items = record[itemsKey];
+		allItems.push(...Array.isArray(items) ? items : []);
+		nextToken = record.NextToken;
+	} while (nextToken);
+	return {
+		allItems,
+		lastResponse
+	};
+});
+//#endregion
+//#region ../../packages/aws-utils/dist/inputs/awsRegion.js
+const awsRegion$1 = (0, _prismatic_io_spectral.input)({
+	label: "AWS Region",
+	placeholder: "AWS Region",
+	type: "string",
+	required: false,
+	comments: "AWS provides services in multiple regions, like us-west-2 or eu-west-1.",
+	example: "us-east-1",
+	dataSource: "selectRegion",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Connection",
+	type: "connection",
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Dynamic Access Key ID",
+	type: "string",
+	required: false,
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Use this input to authenticate with AWS if you are using a dynamically-generated access key. Otherwise, use the connection to enter a static access key ID."
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Dynamic Secret Access Key",
+	type: "password",
+	required: false,
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Use this input to authenticate with AWS if you are using a dynamically-generated secret access key. Otherwise, use the connection to enter a static secret access key."
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Dynamic Session Token",
+	type: "password",
+	required: false,
+	clean: (value) => _prismatic_io_spectral.util.types.toString(value) || void 0,
+	comments: "Use this input to authenticate with AWS if you are using a OPTIONAL dynamically-generated session token."
+});
+//#endregion
+//#region src/connections/index.ts
+const accessKeySecretPair = (0, _prismatic_io_spectral.connection)({
+	key: "awsAccessKeySecret",
+	display: {
+		label: "Access Key and Secret",
+		description: "Authenticate requests to AWS using an Access Key and Secret Key."
+	},
+	inputs: {
+		accessKeyId: {
+			label: "Access Key ID",
+			type: "string",
+			required: true,
+			comments: "The AWS Access Key ID used to authenticate requests to the Redshift Data API.",
+			example: "AKIAIOSFODNN7EXAMPLE",
+			placeholder: "Enter the AWS Access Key ID"
+		},
+		secretAccessKey: {
+			label: "Secret Access Key",
+			type: "password",
+			required: true,
+			comments: "The AWS Secret Access Key paired with the Access Key ID for request signing.",
+			example: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
+		}
+	}
+});
+var connections_default = [accessKeySecretPair, assumeRoleConnection];
+//#endregion
+//#region src/util/index.ts
+const toOptionalString = (value) => value ? _prismatic_io_spectral.util.types.toString(value) : void 0;
+const toOptionalResultFormatString = (value) => value ? _prismatic_io_spectral.util.types.toString(value) : void 0;
+const cleanSqlParameters = (sqlParameters) => Array.isArray(sqlParameters) && sqlParameters.length > 0 ? sqlParameters.map(({ name, value }) => ({
+	name,
+	value
+})) : void 0;
+const toOptionalNumber = (value) => value ? _prismatic_io_spectral.util.types.toNumber(value) : void 0;
+const connectionKeys = [accessKeySecretPair.key, assumeRoleConnection.key];
+const validateConnection = (connection) => {
+	if (!connectionKeys.includes(connection.key)) throw new _prismatic_io_spectral.ConnectionError(connection, `Unsupported connection method ${connection.key}. Supported methods: ${connectionKeys.join(", ")}`);
+};
+const getAllStatements = async ({ client, databaseName, workgroupName, clusterIdentifier, status, statementName }) => {
+	const { allItems, lastResponse } = await paginateAwsResults({
+		client,
+		createCommand: (token) => new _aws_sdk_client_redshift_data.ListStatementsCommand({
+			Database: databaseName,
+			WorkgroupName: workgroupName,
+			ClusterIdentifier: clusterIdentifier,
+			Status: status,
+			StatementName: statementName,
+			MaxResults: 100,
+			NextToken: token
+		}),
+		itemsKey: "Statements"
+	});
+	return {
+		allStatements: allItems,
+		lastResponse
+	};
+};
+//#endregion
+//#region src/client.ts
+const createRedshiftClient = async (connection, region, debug) => {
+	validateConnection(connection);
+	try {
+		const { region: awsRegion, credentials } = await getClientParams({
+			awsConnection: connection,
+			awsRegion: region,
+			validConnectionKeys: connectionKeys,
+			dynamicAccessKeyId: "",
+			dynamicSecretAccessKey: "",
+			dynamicSessionToken: void 0
+		});
+		const client = new _aws_sdk_client_redshift_data.RedshiftDataClient({
+			region: awsRegion,
+			credentials
+		});
+		if (debug) client.middlewareStack.add((next, context) => async (args) => {
+			console.log("Request:", {
+				input: args.input,
+				commandName: context.commandName
+			});
+			try {
+				const result = await next(args);
+				console.log("Response:", result.output);
+				return result;
+			} catch (error) {
+				console.error("Error:", error);
+				throw error;
+			}
+		}, {
+			step: "initialize",
+			name: "logRequestResponseMiddleware"
+		});
+		return client;
+	} catch (error) {
+		throw new _prismatic_io_spectral.ConnectionError(connection, `Failed to create AWS Redshift Data API client: ${error.message}`);
+	}
+};
+const getRedshiftDataApiClient = async (connection, region, debug) => {
+	validateConnection(connection);
+	const { region: awsRegion, credentials } = await getClientParams({
+		awsConnection: connection,
+		awsRegion: region,
+		validConnectionKeys: connectionKeys,
+		dynamicAccessKeyId: "",
+		dynamicSecretAccessKey: "",
+		dynamicSessionToken: void 0
+	});
+	const host = `redshift-data.${awsRegion}.amazonaws.com`;
+	return {
+		client: (0, _prismatic_io_spectral_http.createClient)({
+			baseUrl: `https://${host}`,
+			debug
+		}),
+		credentials,
+		host
+	};
+};
+//#endregion
+//#region src/inputs/common.ts
+const awsRegion = (0, _prismatic_io_spectral.input)({
+	...awsRegion$1,
+	required: true
+});
+const awsConnection = (0, _prismatic_io_spectral.input)({
+	label: "AWS Connection",
+	type: "connection",
+	required: true,
+	comments: "Select the AWS connection to use for Redshift Data API access."
+});
+const databaseName = (0, _prismatic_io_spectral.input)({
+	label: "Database Name",
+	type: "string",
+	required: true,
+	comments: "The name of the database to connect to. This parameter is required when authenticating using either Secrets Manager or temporary credentials.",
+	example: "analytics",
+	placeholder: "Enter the database name",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const clusterIdentifier = (0, _prismatic_io_spectral.input)({
+	label: "Cluster Identifier",
+	type: "string",
+	required: false,
+	comments: "The identifier of the Redshift cluster. Required for cluster connections using either Secrets Manager or temporary credentials.",
+	example: "my-redshift-cluster",
+	placeholder: "Enter the cluster identifier",
+	clean: toOptionalString
+});
+const workgroupName = (0, _prismatic_io_spectral.input)({
+	label: "Workgroup Name",
+	type: "string",
+	required: false,
+	comments: "The name of the Redshift serverless workgroup. This parameter is required when connecting to a serverless workgroup and authenticating using either Secrets Manager or temporary credentials.",
+	example: "my-workgroup",
+	placeholder: "Enter the workgroup name",
+	clean: toOptionalString
+});
+const statementId = (0, _prismatic_io_spectral.input)({
+	label: "Statement ID",
+	type: "string",
+	required: true,
+	comments: "The unique identifier of the executed SQL statement returned by the Redshift Data API.",
+	example: "12345678-1234-1234-1234-123456789012",
+	placeholder: "Enter the statement ID",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const fetchAll = (0, _prismatic_io_spectral.input)({
+	label: "Fetch All",
+	type: "boolean",
+	comments: "When enabled, automatically fetches all pages of results. Next Token and Max Results inputs are ignored when this is enabled.",
+	required: false,
+	default: "false",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const statementName = (0, _prismatic_io_spectral.input)({
+	label: "Statement Name",
+	type: "string",
+	required: false,
+	comments: "A descriptive label assigned to the SQL statement to help identify it when listing or filtering statements later.",
+	example: "GetActiveUsers",
+	placeholder: "Enter the statement name",
+	clean: toOptionalString
+});
+//#endregion
+//#region src/constants.ts
+const RESULT_FORMAT_OPTIONS = [{
+	label: "JSON",
+	value: "JSON"
+}, {
+	label: "CSV",
+	value: "CSV"
+}];
+const STATUS_OPTIONS = [
+	{
+		label: "ALL",
+		value: "ALL"
+	},
+	{
+		label: "ABORTED",
+		value: "ABORTED"
+	},
+	{
+		label: "FAILED",
+		value: "FAILED"
+	},
+	{
+		label: "FINISHED",
+		value: "FINISHED"
+	},
+	{
+		label: "PICKED",
+		value: "PICKED"
+	},
+	{
+		label: "STARTED",
+		value: "STARTED"
+	},
+	{
+		label: "SUBMITTED",
+		value: "SUBMITTED"
+	}
+];
+const RAW_REQUEST_ACTION_OPTIONS = [
+	{
+		label: "BatchExecuteStatement",
+		value: "RedshiftData.BatchExecuteStatement"
+	},
+	{
+		label: "CancelStatement",
+		value: "RedshiftData.CancelStatement"
+	},
+	{
+		label: "DescribeStatement",
+		value: "RedshiftData.DescribeStatement"
+	},
+	{
+		label: "DescribeTable",
+		value: "RedshiftData.DescribeTable"
+	},
+	{
+		label: "ExecuteStatement",
+		value: "RedshiftData.ExecuteStatement"
+	},
+	{
+		label: "GetStatementResult",
+		value: "RedshiftData.GetStatementResult"
+	},
+	{
+		label: "GetStatementResultV2",
+		value: "RedshiftData.GetStatementResultV2"
+	},
+	{
+		label: "ListDatabases",
+		value: "RedshiftData.ListDatabases"
+	},
+	{
+		label: "ListSchemas",
+		value: "RedshiftData.ListSchemas"
+	},
+	{
+		label: "ListStatements",
+		value: "RedshiftData.ListStatements"
+	},
+	{
+		label: "ListTables",
+		value: "RedshiftData.ListTables"
+	}
+];
+//#endregion
+//#region src/inputs/statement.ts
+const databaseUser = (0, _prismatic_io_spectral.input)({
+	label: "Database User",
+	type: "string",
+	required: false,
+	comments: "The database user name. This parameter is required when connecting to a cluster as a database user and authenticating using temporary credentials.",
+	example: "admin",
+	placeholder: "Enter the database user",
+	clean: toOptionalString
+});
+const secretArn = (0, _prismatic_io_spectral.input)({
+	label: "Secret ARN",
+	type: "string",
+	required: false,
+	comments: "The ARN of the AWS Secrets Manager secret containing database credentials. Required when authenticating using Secrets Manager.",
+	example: "arn:aws:secretsmanager:us-east-1:123456789012:secret:redshift-credentials",
+	placeholder: "Enter the secret ARN",
+	clean: toOptionalString
+});
+const sqlStatement = (0, _prismatic_io_spectral.input)({
+	label: "SQL Statement",
+	type: "code",
+	language: "sql",
+	required: true,
+	comments: "The SQL statement to run against the Redshift database. Supports DML (INSERT, UPDATE, DELETE), DDL (CREATE, DROP, ALTER), and query (SELECT) statements.",
+	example: "SELECT * FROM users WHERE status = :status",
+	placeholder: "SELECT * FROM users WHERE status = :status",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const sqlParameters = (0, _prismatic_io_spectral.input)({
+	label: "SQL Parameters",
+	type: "string",
+	collection: "keyvaluelist",
+	required: false,
+	comments: "Named parameters that are substituted into the SQL statement at runtime using the colon-prefixed placeholder syntax (e.g., :status).",
+	example: "status: active, limit: 100",
+	clean: cleanSqlParameters
+});
+const resultFormat = (0, _prismatic_io_spectral.input)({
+	label: "Result Format",
+	type: "string",
+	required: false,
+	default: "JSON",
+	comments: "The format for query results (JSON or CSV).",
+	example: "JSON",
+	placeholder: "Enter the result format",
+	model: RESULT_FORMAT_OPTIONS,
+	clean: toOptionalResultFormatString
+});
+const sessionId = (0, _prismatic_io_spectral.input)({
+	label: "Session ID",
+	type: "string",
+	required: false,
+	comments: "The ID of an existing session to reuse for statement execution, enabling multiple statements to share temporary tables and transaction state.",
+	example: "session-12345678",
+	placeholder: "Enter the session ID",
+	clean: toOptionalString
+});
+const sessionKeepAliveSeconds = (0, _prismatic_io_spectral.input)({
+	label: "Session Keep Alive (seconds)",
+	type: "string",
+	required: false,
+	comments: "Number of seconds to keep the session alive after query completion (max 24 hours).",
+	example: "3600",
+	placeholder: "Enter the keep alive duration in seconds",
+	clean: toOptionalNumber
+});
+const clientToken = (0, _prismatic_io_spectral.input)({
+	label: "Client Token",
+	type: "string",
+	required: false,
+	comments: "Unique identifier to ensure idempotency of the request.",
+	example: "client-token-123",
+	placeholder: "Enter the client token",
+	clean: toOptionalString
+});
+const getStatementResult$1 = (0, _prismatic_io_spectral.input)({
+	label: "Get Statement Result",
+	type: "boolean",
+	required: false,
+	comments: "When true, waits for the statement to finish executing and returns its result set. Only SELECT statements produce result rows. <strong>Note:</strong> long-running statements may cause a timeout.",
+	example: "true",
+	default: "true",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const nextToken = (0, _prismatic_io_spectral.input)({
+	label: "Next Token",
+	type: "string",
+	required: false,
+	comments: "The pagination token returned from a previous list request, used to retrieve the next page of results.",
+	example: "AQICAHi2k9rFZ...",
+	placeholder: "Enter the next token",
+	clean: toOptionalString
+});
+const status = (0, _prismatic_io_spectral.input)({
+	label: "Status",
+	type: "string",
+	required: true,
+	comments: "Filters the returned statements to only those matching this execution status. Use ALL to retrieve statements in any state.",
+	example: "ALL",
+	model: STATUS_OPTIONS,
+	default: "ALL",
+	clean: (value) => _prismatic_io_spectral.util.types.toString(value)
+});
+const executeStatementInputs = {
+	awsConnection,
+	sqlStatement,
+	databaseName,
+	awsRegion,
+	workgroupName,
+	clusterIdentifier,
+	getStatementResult: getStatementResult$1,
+	databaseUser,
+	secretArn,
+	sqlParameters,
+	additionalFields: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Additional Fields",
+		required: false,
+		comments: "Additional optional fields: includes Statement Name, Result Format, Session Keep Alive (seconds), Client Token, and Session ID.",
+		inputs: {
+			statementName,
+			resultFormat,
+			sessionKeepAliveSeconds,
+			clientToken,
+			sessionId
+		}
+	})
+};
+const getStatementResultInputs = {
+	awsConnection,
+	statementId: {
+		...statementId,
+		comments: `${statementId.comments} <strong>Note:</strong> Only statements that return results are supported.`
+	},
+	awsRegion,
+	nextToken
+};
+const pagination = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Pagination",
+	required: false,
+	comments: "Page and page-size controls.",
+	inputs: {
+		nextToken,
+		maxResults: (0, _prismatic_io_spectral.input)({
+			label: "Max Results",
+			type: "string",
+			required: false,
+			comments: "The maximum number of SQL statements to return per page. Valid range: 0-100.",
+			example: "100",
+			placeholder: "100",
+			clean: toOptionalNumber
+		})
+	}
+});
+const listStatementsInputs = {
+	awsConnection,
+	awsRegion,
+	status,
+	filters: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Filters",
+		required: false,
+		comments: "Optional filters to narrow the returned statements by database, workgroup, cluster, and statement name.",
+		inputs: {
+			databaseName: {
+				...databaseName,
+				required: false,
+				comments: "The name of the database when listing statements run against a <code>ClusterIdentifier</code> or <code>WorkgroupName</code>."
+			},
+			workgroupName: {
+				...workgroupName,
+				required: false,
+				comments: "The serverless workgroup name or Amazon Resource Name (ARN). Only statements that ran on this workgroup are returned. When providing <code>WorkgroupName</code>, then <code>ClusterIdentifier</code> can't be specified."
+			},
+			clusterIdentifier: {
+				...clusterIdentifier,
+				required: false,
+				comments: "The cluster identifier. Only statements that ran on this cluster are returned. When providing <code>ClusterIdentifier</code>, then <code>WorkgroupName</code> can't be specified."
+			},
+			statementName: {
+				...statementName,
+				comments: "The name of the SQL statement specified as input to <code>BatchExecuteStatement</code> or <code>ExecuteStatement</code> to identify the query. Multiple statements can be matched by providing a prefix that matches the beginning of the statement name."
+			}
+		}
+	}),
+	fetchAll,
+	pagination
+};
+const describeStatementInputs = {
+	awsConnection,
+	statementId,
+	awsRegion
+};
+const rawRequestInputs = {
+	awsConnection,
+	awsRegion,
+	body: (0, _prismatic_io_spectral.input)({
+		label: "Body",
+		type: "code",
+		language: "json",
+		required: true,
+		comments: "The JSON payload sent to the selected Redshift Data API operation. The required fields vary by action — refer to the AWS Redshift Data API documentation for the expected structure of each operation.",
+		example: JSON.stringify({
+			WorkgroupName: "my-workgroup",
+			Database: "analytics",
+			Sql: "SELECT * FROM users WHERE status = 'active'",
+			SecretArn: "arn:aws:secretsmanager:us-east-1:123456789012:secret:redshift-credentials"
+		}, null, 2),
+		clean: _prismatic_io_spectral.util.types.toString
+	}),
+	action: (0, _prismatic_io_spectral.input)({
+		label: "Action",
+		type: "string",
+		required: true,
+		comments: "The Redshift Data API operation to invoke. Determines which API method is called with the provided body.",
+		example: "RedshiftData.ExecuteStatement",
+		placeholder: "Enter the action",
+		model: RAW_REQUEST_ACTION_OPTIONS,
+		clean: _prismatic_io_spectral.util.types.toString
+	})
+};
+//#endregion
+//#region src/actions/misc/index.ts
+var misc_default = { rawRequest: (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Raw Request",
+		description: "Send raw HTTP request to Redshift Data API."
+	},
+	inputs: rawRequestInputs,
+	perform: async (context, { awsConnection, awsRegion, body, action }) => {
+		const { client, credentials, host } = await getRedshiftDataApiClient(awsConnection, awsRegion, context.debug.enabled);
+		const requestOpts = {
+			host,
+			path: "/",
+			service: "redshift-data",
+			region: awsRegion,
+			method: "POST",
+			headers: {
+				"Content-Type": "application/x-amz-json-1.1",
+				"X-Amz-Target": action
+			},
+			body
+		};
+		(0, aws4.sign)(requestOpts, credentials);
+		const { data } = await client.post("/", requestOpts.body, { headers: requestOpts.headers });
+		return { data };
+	}
+}) };
+//#endregion
+//#region src/examplePayloads/getStatementResultExamplePayload.ts
+const getStatementResultExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "example-request-id-12345-67890-abcdef",
+		extendedRequestId: void 0,
+		cfId: void 0,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	ColumnMetadata: [
+		{
+			isCaseSensitive: false,
+			isCurrency: false,
+			isSigned: true,
+			label: "id",
+			length: 0,
+			name: "id",
+			nullable: 1,
+			precision: 10,
+			scale: 0,
+			schemaName: "public",
+			tableName: "users",
+			typeName: "int4"
+		},
+		{
+			isCaseSensitive: true,
+			isCurrency: false,
+			isSigned: false,
+			label: "name",
+			length: 0,
+			name: "name",
+			nullable: 1,
+			precision: 50,
+			scale: 0,
+			schemaName: "public",
+			tableName: "users",
+			typeName: "varchar"
+		},
+		{
+			isCaseSensitive: true,
+			isCurrency: false,
+			isSigned: false,
+			label: "email",
+			length: 0,
+			name: "email",
+			nullable: 1,
+			precision: 100,
+			scale: 0,
+			schemaName: "public",
+			tableName: "users",
+			typeName: "varchar"
+		}
+	],
+	Records: [[
+		{ longValue: 1 },
+		{ stringValue: "Alice" },
+		{ stringValue: "alice@example.com" }
+	]],
+	TotalNumRows: 1
+} };
+//#endregion
+//#region src/examplePayloads/executeStatementExamplePayload.ts
+const executeStatementExamplePayload = { data: {
+	executeStatement: {
+		$metadata: {
+			httpStatusCode: 200,
+			requestId: "example-request-id-12345-67890-abcdef",
+			extendedRequestId: void 0,
+			cfId: void 0,
+			attempts: 1,
+			totalRetryDelay: 0
+		},
+		CreatedAt: /* @__PURE__ */ new Date("2025-01-15T10:30:00.000Z"),
+		Database: "example_database",
+		Id: "example-statement-id-12345-67890-abcdef",
+		SecretArn: "arn:aws:secretsmanager:us-east-1:123456789012:secret:redshift/example-secret-abc123",
+		WorkgroupName: "example_workgroup"
+	},
+	statementResults: getStatementResultExamplePayload.data
+} };
+//#endregion
+//#region src/examplePayloads/listStatementsExamplePayload.ts
+const listStatementsExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "example-list-request-id-12345-67890-abcdef",
+		extendedRequestId: void 0,
+		cfId: void 0,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	Statements: [{
+		CreatedAt: /* @__PURE__ */ new Date("2025-01-15T10:30:00.000Z"),
+		Id: "example-statement-id-12345-67890-abcdef",
+		QueryString: "CREATE TABLE users (\n  id INT,\n  name VARCHAR(50),\n  email VARCHAR(100)\n);\n",
+		ResultFormat: "JSON",
+		SecretArn: "arn:aws:secretsmanager:us-east-1:123456789012:secret:redshift/example-secret-abc123",
+		StatementName: "ExampleStatement",
+		Status: "PICKED",
+		UpdatedAt: /* @__PURE__ */ new Date("2025-01-15T10:31:00.000Z")
+	}]
+} };
+//#endregion
+//#region src/examplePayloads/describeStatementExamplePayload.ts
+const describeStatementExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "example-request-id-12345-67890-abcdef",
+		extendedRequestId: void 0,
+		cfId: void 0,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	CreatedAt: /* @__PURE__ */ new Date("2025-01-15T10:30:00.000Z"),
+	Database: "example_database",
+	Duration: 257716773,
+	HasResultSet: false,
+	Id: "example-statement-id-12345-67890-abcdef",
+	QueryString: "INSERT INTO example_table (id, name, email)\nVALUES (1, 'Example User', 'user@example.com');\n",
+	RedshiftPid: 123456789,
+	RedshiftQueryId: 987654,
+	ResultFormat: "JSON",
+	ResultRows: 1,
+	ResultSize: 0,
+	SecretArn: "arn:aws:secretsmanager:us-east-1:123456789012:secret:redshift/example-secret-name",
+	Status: "FINISHED",
+	UpdatedAt: /* @__PURE__ */ new Date("2025-01-15T10:31:00.000Z"),
+	WorkgroupName: "example-workgroup"
+} };
+//#endregion
+//#region src/actions/statements/index.ts
+var statements_default = {
+	describeStatement: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Describe Statement",
+			description: "Get detailed information about a specific SQL statement in Redshift."
+		},
+		inputs: describeStatementInputs,
+		perform: async (context, { awsConnection, awsRegion, statementId }) => {
+			const client = await createRedshiftClient(awsConnection, awsRegion, context.debug.enabled);
+			const command = new _aws_sdk_client_redshift_data.DescribeStatementCommand({ Id: statementId });
+			return { data: await client.send(command) };
+		},
+		examplePayload: describeStatementExamplePayload
+	}),
+	executeStatement: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Execute SQL Statement",
+			description: "Execute a SQL statement in Redshift."
+		},
+		inputs: executeStatementInputs,
+		perform: async (context, { awsConnection, sqlStatement, databaseName, awsRegion, workgroupName, clusterIdentifier, getStatementResult, databaseUser, secretArn, sqlParameters, additionalFields = {} }) => {
+			const client = await createRedshiftClient(awsConnection, awsRegion, context.debug.enabled);
+			if (!clusterIdentifier && !workgroupName) throw new Error("Either Cluster Identifier or Workgroup Name must be provided");
+			const command = new _aws_sdk_client_redshift_data.ExecuteStatementCommand({
+				Sql: sqlStatement,
+				Database: databaseName,
+				StatementName: additionalFields.statementName,
+				DbUser: databaseUser,
+				SecretArn: secretArn,
+				Parameters: sqlParameters,
+				ResultFormat: additionalFields.resultFormat,
+				SessionId: additionalFields.sessionId,
+				SessionKeepAliveSeconds: additionalFields.sessionKeepAliveSeconds,
+				ClientToken: additionalFields.clientToken,
+				ClusterIdentifier: clusterIdentifier,
+				WorkgroupName: workgroupName
+			});
+			const response = await client.send(command);
+			if (!getStatementResult) return { data: { executeStatement: response } };
+			const id = response.Id;
+			if (!id) throw new Error("Statement ID not found in execute statement response");
+			const describeCommandInput = { Id: id };
+			let needsToWait = true;
+			let status;
+			let hasResultSet = false;
+			do {
+				const describeCommand = new _aws_sdk_client_redshift_data.DescribeStatementCommand(describeCommandInput);
+				const describeResponse = await client.send(describeCommand);
+				status = describeResponse.Status;
+				if (!status) throw new Error("Status not found in describe statement response");
+				needsToWait = ![
+					"FINISHED",
+					"FAILED",
+					"ABORTED"
+				].includes(status);
+				hasResultSet = describeResponse.HasResultSet ?? false;
+				await new Promise((resolve) => setTimeout(resolve, 1e3));
+			} while (needsToWait);
+			if (status === _aws_sdk_client_redshift_data.StatusString.FAILED) throw new Error("Statement failed");
+			if (status === _aws_sdk_client_redshift_data.StatusString.ABORTED) throw new Error("Statement aborted");
+			if (hasResultSet) {
+				const getStatementResultCommand = new _aws_sdk_client_redshift_data.GetStatementResultCommand({ Id: id });
+				return { data: {
+					executeStatement: response,
+					statementResults: await client.send(getStatementResultCommand)
+				} };
+			}
+			return { data: {
+				executeStatement: response,
+				statementResults: null
+			} };
+		},
+		examplePayload: executeStatementExamplePayload
+	}),
+	getStatementResult: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Statement Result",
+			description: "Retrieve the results of an executed SQL statement from Redshift."
+		},
+		inputs: getStatementResultInputs,
+		perform: async (context, { awsConnection, awsRegion, statementId, nextToken }) => {
+			const client = await createRedshiftClient(awsConnection, awsRegion, context.debug.enabled);
+			const command = new _aws_sdk_client_redshift_data.GetStatementResultCommand({
+				Id: statementId,
+				NextToken: nextToken
+			});
+			return { data: await client.send(command) };
+		},
+		examplePayload: getStatementResultExamplePayload
+	}),
+	listStatements: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Statements",
+			description: "List executed SQL statements in Redshift."
+		},
+		inputs: listStatementsInputs,
+		perform: async (context, { awsConnection, awsRegion, status, fetchAll, filters = {}, pagination = {} }) => {
+			const client = await createRedshiftClient(awsConnection, awsRegion, context.debug.enabled);
+			if (fetchAll) {
+				const { allStatements, lastResponse } = await getAllStatements({
+					client,
+					databaseName: filters.databaseName,
+					workgroupName: filters.workgroupName,
+					clusterIdentifier: filters.clusterIdentifier,
+					status,
+					statementName: filters.statementName
+				});
+				return { data: {
+					...lastResponse,
+					Statements: allStatements
+				} };
+			}
+			const command = new _aws_sdk_client_redshift_data.ListStatementsCommand({
+				Database: filters.databaseName,
+				WorkgroupName: filters.workgroupName,
+				ClusterIdentifier: filters.clusterIdentifier,
+				Status: status,
+				StatementName: filters.statementName,
+				NextToken: pagination.nextToken,
+				MaxResults: pagination.maxResults
+			});
+			return { data: await client.send(command) };
+		},
+		examplePayload: listStatementsExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/index.ts
+var actions_default = {
+	...misc_default,
+	...statements_default
+};
+//#endregion
+//#region src/dataSources/index.ts
+var dataSources_default = { selectRegion };
+//#endregion
+//#region src/index.ts
+var src_default = (0, _prismatic_io_spectral.component)({
+	key: "aws-redshift",
+	public: true,
+	display: {
+		label: "Redshift",
+		description: "Execute SQL statements and manage data in Amazon Redshift using the AWS Redshift Data API",
+		iconPath: "icon.png",
+		category: "Application Connectors"
+	},
+	documentationUrl: "https://prismatic.io/docs/components/aws-redshift/",
+	connections: connections_default,
+	dataSources: dataSources_default,
+	actions: actions_default,
+	hooks: { error: _prismatic_io_spectral_http.handleErrors }
+});
+//#endregion
+//#region npm-dist/.entry.ts
+var _entry_default = (0, _prismatic_io_spectral.callableComponent)(src_default);
+//#endregion
+module.exports = _entry_default;