sailfork / t3code-github / .repos/ alchemy-effect/ packages/ aws/ src/ RedshiftData/ StatementsHttp.ts

import * as data from "@distilled.cloud/aws/redshift-data";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Schedule from "effect/Schedule";
import * as AWSBindings from "../AWSBindings.ts";
import type { Workgroup } from "../RedshiftServerless/Workgroup.ts";
import {
  RedshiftStatementFailed,
  Statements,
  type BatchExecuteStatementRequest,
  type DescribeTableRequest,
  type ExecuteStatementRequest,
  type ListDatabasesRequest,
  type ListSchemasRequest,
  type ListStatementsRequest,
  type ListTablesRequest,
  type StatementsClient,
  type StatementsOptions,
} from "./Statements.ts";

/** Statement statuses that mean the run is over. */
const isTerminal = (status: string | undefined): boolean =>
  status === "FINISHED" || status === "FAILED" || status === "ABORTED";

export const StatementsHttp = Layer.effect(
  Statements,
  Effect.gen(function* () {
    const bind = yield* AWSBindings.Bind;
    const executeStatement = yield* AWSBindings.withCredentials(data.executeStatement);
    const batchExecuteStatement = yield* AWSBindings.withCredentials(data.batchExecuteStatement);
    const describeStatement = yield* AWSBindings.withCredentials(data.describeStatement);
    const cancelStatement = yield* AWSBindings.withCredentials(data.cancelStatement);
    const getStatementResult = yield* AWSBindings.withCredentials(data.getStatementResult);
    const getStatementResultV2 = yield* AWSBindings.withCredentials(data.getStatementResultV2);
    const describeTableOp = yield* AWSBindings.withCredentials(data.describeTable);
    const listDatabasesOp = yield* AWSBindings.withCredentials(data.listDatabases);
    const listSchemasOp = yield* AWSBindings.withCredentials(data.listSchemas);
    const listTablesOp = yield* AWSBindings.withCredentials(data.listTables);
    const listStatementsOp = yield* AWSBindings.withCredentials(data.listStatements);

    return Effect.fn(function* (workgroup: Workgroup, options: StatementsOptions = {}) {
      const workgroupName = yield* workgroup.workgroupName;
      if (!globalThis.__ALCHEMY_RUNTIME__) {
        yield* bind`AWS.RedshiftData.Statements(${workgroup})`({
          policyStatements: [
            {
              // Workgroup-scoped Data API actions (submit statements and
              // read database metadata through the workgroup).
              Effect: "Allow",
              Action: [
                "redshift-data:ExecuteStatement",
                "redshift-data:BatchExecuteStatement",
                "redshift-data:DescribeTable",
                "redshift-data:ListDatabases",
                "redshift-data:ListSchemas",
                "redshift-data:ListTables",
              ],
              Resource: [workgroup.workgroupArn],
            },
            {
              // Statement-scoped actions are authorized per-statement
              // (owner condition), not by ARN.
              Effect: "Allow",
              Action: [
                "redshift-data:DescribeStatement",
                "redshift-data:GetStatementResult",
                "redshift-data:GetStatementResultV2",
                "redshift-data:CancelStatement",
                "redshift-data:ListStatements",
              ],
              Resource: ["*"],
            },
            {
              // IAM temporary-credential auth against the serverless
              // workgroup (used when no SecretArn is supplied).
              Effect: "Allow",
              Action: ["redshift-serverless:GetCredentials"],
              Resource: [workgroup.workgroupArn],
            },
            ...(options.secretArn
              ? [
                  {
                    Effect: "Allow" as const,
                    Action: ["secretsmanager:GetSecretValue", "secretsmanager:DescribeSecret"],
                    Resource: [options.secretArn],
                  },
                ]
              : []),
          ],
        });
      }

      const database = options.database ?? "dev";

      const execute = Effect.fn(`AWS.RedshiftData.Statements.execute(${workgroup.LogicalId})`)(
        function* (request: ExecuteStatementRequest) {
          return yield* executeStatement({
            ...request,
            WorkgroupName: yield* workgroupName,
            Database: database,
            SecretArn: options.secretArn,
            DbUser: options.dbUser,
          });
        },
      );

      const executeBatch = Effect.fn(
        `AWS.RedshiftData.Statements.executeBatch(${workgroup.LogicalId})`,
      )(function* (request: BatchExecuteStatementRequest) {
        return yield* batchExecuteStatement({
          ...request,
          WorkgroupName: yield* workgroupName,
          Database: database,
          SecretArn: options.secretArn,
          DbUser: options.dbUser,
        });
      });

      const describe = Effect.fn(`AWS.RedshiftData.Statements.describe(${workgroup.LogicalId})`)(
        function* (id: string) {
          return yield* describeStatement({ Id: id });
        },
      );

      const cancel = Effect.fn(`AWS.RedshiftData.Statements.cancel(${workgroup.LogicalId})`)(
        function* (id: string) {
          return yield* cancelStatement({ Id: id });
        },
      );

      const getResult = Effect.fn(`AWS.RedshiftData.Statements.getResult(${workgroup.LogicalId})`)(
        function* (id: string, nextToken?: string) {
          return yield* getStatementResult({ Id: id, NextToken: nextToken });
        },
      );

      const getResultV2 = Effect.fn(
        `AWS.RedshiftData.Statements.getResultV2(${workgroup.LogicalId})`,
      )(function* (id: string, nextToken?: string) {
        return yield* getStatementResultV2({ Id: id, NextToken: nextToken });
      });

      const describeTable = Effect.fn(
        `AWS.RedshiftData.Statements.describeTable(${workgroup.LogicalId})`,
      )(function* (request: DescribeTableRequest) {
        return yield* describeTableOp({
          ...request,
          WorkgroupName: yield* workgroupName,
          Database: database,
          SecretArn: options.secretArn,
          DbUser: options.dbUser,
        });
      });

      const listDatabases = Effect.fn(
        `AWS.RedshiftData.Statements.listDatabases(${workgroup.LogicalId})`,
      )(function* (request: ListDatabasesRequest = {}) {
        return yield* listDatabasesOp({
          ...request,
          WorkgroupName: yield* workgroupName,
          Database: database,
          SecretArn: options.secretArn,
          DbUser: options.dbUser,
        });
      });

      const listSchemas = Effect.fn(
        `AWS.RedshiftData.Statements.listSchemas(${workgroup.LogicalId})`,
      )(function* (request: ListSchemasRequest = {}) {
        return yield* listSchemasOp({
          ...request,
          WorkgroupName: yield* workgroupName,
          Database: database,
          SecretArn: options.secretArn,
          DbUser: options.dbUser,
        });
      });

      const listTables = Effect.fn(
        `AWS.RedshiftData.Statements.listTables(${workgroup.LogicalId})`,
      )(function* (request: ListTablesRequest = {}) {
        return yield* listTablesOp({
          ...request,
          WorkgroupName: yield* workgroupName,
          Database: database,
          SecretArn: options.secretArn,
          DbUser: options.dbUser,
        });
      });

      const listStatements = Effect.fn(
        `AWS.RedshiftData.Statements.listStatements(${workgroup.LogicalId})`,
      )(function* (request: ListStatementsRequest = {}) {
        return yield* listStatementsOp({
          ...request,
          WorkgroupName: yield* workgroupName,
        });
      });

      const query = Effect.fn(`AWS.RedshiftData.Statements.query(${workgroup.LogicalId})`)(
        function* (sql: string, parameters?: data.SqlParameter[]) {
          const submitted = yield* execute({ Sql: sql, Parameters: parameters });
          const id = submitted.Id!;
          // Poll until the statement reaches a terminal status. Redshift
          // Serverless typically finishes simple statements in a few seconds;
          // budget ~2.5 min (30 * 5s).
          const described = yield* describe(id).pipe(
            Effect.repeat({
              schedule: Schedule.spaced("5 seconds"),
              until: (r) => isTerminal(r.Status),
              times: 30,
            }),
          );
          if (described.Status !== "FINISHED") {
            return yield* new RedshiftStatementFailed({
              statementId: id,
              status: described.Status ?? "UNKNOWN",
              error: described.Error,
            });
          }
          return yield* getResult(id);
        },
      );

      return {
        execute,
        executeBatch,
        describe,
        cancel,
        getResult,
        getResultV2,
        describeTable,
        listDatabases,
        listSchemas,
        listTables,
        listStatements,
        query,
      } satisfies StatementsClient;
    });
  }),
);