import * as athena from "@distilled.cloud/aws/athena";
import * as Output from "alchemy/Output";
import type { Output as OutputType } from "alchemy/Output";
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 { Bucket } from "../S3/Bucket.ts";
import { AthenaQueryFailed, Query, type QueryResult, type RunQueryRequest } from "./Query.ts";
import type { WorkGroup } from "./WorkGroup.ts";
// The workgroup ARN is `arn:aws:athena:{region}:{account}:workgroup/{name}` —
// the Glue Data Catalog ARNs share that partition/region/account.
const glueBase = (workGroupArn: OutputType<string>) =>
workGroupArn.pipe(
Output.map((arn) => {
const [, partition, , region, account] = arn.split(":");
return `arn:${partition}:glue:${region}:${account}`;
}),
);
const glueCatalogArn = (workGroupArn: OutputType<string>) =>
glueBase(workGroupArn).pipe(Output.map((base) => `${base}:catalog`));
const glueDatabaseArn = (workGroupArn: OutputType<string>) =>
glueBase(workGroupArn).pipe(Output.map((base) => `${base}:database/*`));
const glueTableArn = (workGroupArn: OutputType<string>) =>
glueBase(workGroupArn).pipe(Output.map((base) => `${base}:table/*/*`));
export const QueryHttp = Layer.effect(
Query,
Effect.gen(function* () {
const bind = yield* AWSBindings.Bind;
const startQueryExecution = yield* AWSBindings.withCredentials(athena.startQueryExecution);
const getQueryExecution = yield* AWSBindings.withCredentials(athena.getQueryExecution);
const getQueryResults = yield* AWSBindings.withCredentials(athena.getQueryResults);
return Effect.fn(function* (workGroup: WorkGroup, resultsBucket: Bucket) {
const WorkGroupName = yield* workGroup.workGroupName;
if (!globalThis.__ALCHEMY_RUNTIME__) {
yield* bind`AWS.Athena.Query(${workGroup}, ${resultsBucket})`({
policyStatements: [
{
Effect: "Allow",
Action: [
"athena:StartQueryExecution",
"athena:GetQueryExecution",
"athena:GetQueryResults",
"athena:StopQueryExecution",
],
Resource: [workGroup.workGroupArn],
},
{
Effect: "Allow",
Action: ["s3:GetBucketLocation", "s3:ListBucket"],
Resource: [resultsBucket.bucketArn],
},
{
Effect: "Allow",
Action: ["s3:GetObject", "s3:PutObject", "s3:AbortMultipartUpload"],
Resource: [Output.interpolate`${resultsBucket.bucketArn}/*`],
},
{
// Athena resolves table metadata through the Glue Data
// Catalog on the caller's behalf — reads are required for any
// query over a Glue-backed table. Scoped to the workgroup's
// account/region catalog (derived from its ARN).
Effect: "Allow",
Action: [
"glue:GetDatabase",
"glue:GetDatabases",
"glue:GetTable",
"glue:GetTables",
"glue:GetPartition",
"glue:GetPartitions",
],
Resource: [
glueCatalogArn(workGroup.workGroupArn),
glueDatabaseArn(workGroup.workGroupArn),
glueTableArn(workGroup.workGroupArn),
],
},
],
});
}
return Effect.fn(`AWS.Athena.Query(${workGroup.LogicalId})`)(function* (
request: RunQueryRequest,
) {
const workGroupName = yield* WorkGroupName;
const started = yield* startQueryExecution({
...request,
WorkGroup: workGroupName,
});
const queryExecutionId = started.QueryExecutionId!;
// Poll GetQueryExecution until terminal — bounded to ~90s so a hung
// query fails fast instead of hitting the caller's timeout.
const exec = yield* getQueryExecution({
QueryExecutionId: queryExecutionId,
}).pipe(
Effect.map((r) => r.QueryExecution),
Effect.repeat({
schedule: Schedule.spaced("1 second"),
until: (qe) => {
const s = qe?.Status?.State;
return s === "SUCCEEDED" || s === "FAILED" || s === "CANCELLED";
},
times: 90,
}),
);
const state = exec?.Status?.State ?? "FAILED";
const reason = exec?.Status?.StateChangeReason;
if (state !== "SUCCEEDED") {
return yield* new AthenaQueryFailed({ queryExecutionId, state, reason });
}
const results = yield* getQueryResults({
QueryExecutionId: queryExecutionId,
});
const columns = (results.ResultSet?.ResultSetMetadata?.ColumnInfo ?? []).map((c) => c.Name);
const rows = (results.ResultSet?.Rows ?? []).map((row) =>
(row.Data ?? []).map((d) => d.VarCharValue ?? ""),
);
return {
queryExecutionId,
state,
stateChangeReason: reason,
columns,
rows,
} satisfies QueryResult;
});
});
}),
);