import * as emr from "@distilled.cloud/aws/emr-serverless";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Schedule from "effect/Schedule";
/**
* Raised when an EMR Serverless application never settles into the expected
* state within the bounded polling budget.
*/
export class EmrServerlessStateTimeout extends Data.TaggedError("EmrServerlessStateTimeout")<{
readonly applicationId: string;
readonly expected: readonly string[];
readonly actual: string | undefined;
readonly stateDetails: string | undefined;
}> {}
/**
* Poll `getApplication` (bounded, spaced 5s, ~2 min budget) until the
* application leaves the given transitional state. Explicitly typed so
* `Effect.repeat`'s conditional return type does not widen the provider layer
* in declaration emit (see PATTERNS §7).
*/
const untilNotInState = <E, R>(
self: Effect.Effect<emr.GetApplicationResponse, E, R>,
transitional: readonly string[],
): Effect.Effect<emr.Application, E, R> =>
Effect.repeat(
Effect.map(self, (response) => response.application),
{
schedule: Schedule.spaced("5 seconds"),
until: (application) => !transitional.includes(application.state),
times: 24,
},
);
/**
* Await an application leaving `CREATING`, failing with
* `EmrServerlessStateTimeout` if it does not settle into `CREATED` (or an
* auto-started `STARTING`/`STARTED`) within the budget.
*/
export const awaitApplicationCreated = Effect.fn("AWS.EMRServerless.awaitApplicationCreated")(
function* (applicationId: string) {
const application = yield* untilNotInState(emr.getApplication({ applicationId }), ["CREATING"]);
const settled = ["CREATED", "STARTING", "STARTED"];
if (!settled.includes(application.state)) {
return yield* new EmrServerlessStateTimeout({
applicationId,
expected: settled,
actual: application.state,
stateDetails: application.stateDetails,
});
}
return application;
},
);
/**
* Await an application settling into an updatable/deletable state (`CREATED`
* or `STOPPED`), draining `STARTING`/`STOPPING` transitions. The caller is
* responsible for issuing `stopApplication` first when the application is
* `STARTED`.
*/
export const awaitApplicationStopped = Effect.fn("AWS.EMRServerless.awaitApplicationStopped")(
function* (applicationId: string) {
const application = yield* untilNotInState(emr.getApplication({ applicationId }), [
"CREATING",
"STARTING",
"STOPPING",
]);
// TERMINATED is tolerated: a concurrent delete winning the race is a settled
// outcome for both the update path (the follow-up call surfaces the truth)
// and the delete path (nothing left to delete).
const settled = ["CREATED", "STOPPED", "TERMINATED"];
if (!settled.includes(application.state)) {
return yield* new EmrServerlessStateTimeout({
applicationId,
expected: settled,
actual: application.state,
stateDetails: application.stateDetails,
});
}
return application;
},
);