import * as appconfig from "@distilled.cloud/aws/appconfig";
import { isResolved } from "alchemy/Diff";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Schedule from "effect/Schedule";
import type { Providers } from "../Providers.ts";
export interface DeploymentProps {
/**
* ID of the application.
*/
applicationId: string;
/**
* ID of the environment to deploy to.
*/
environmentId: string;
/**
* ID of the deployment strategy that governs the rollout.
*/
deploymentStrategyId: string;
/**
* ID of the configuration profile being deployed.
*/
configurationProfileId: string;
/**
* The configuration version to deploy. For a hosted configuration profile
* this is the hosted version number (as a string); for other sources it is
* the version identifier defined by that source.
*/
configurationVersion: string;
/**
* Description of the deployment.
*/
description?: string;
}
export interface Deployment extends Resource<
"AWS.AppConfig.Deployment",
DeploymentProps,
{
applicationId: string;
environmentId: string;
deploymentNumber: number;
configurationProfileId: string;
configurationVersion: string;
state: string;
},
never,
Providers
> {}
/**
* An AWS AppConfig deployment — releases a configuration version to an
* environment following a deployment strategy. Deployments are immutable and
* asynchronous: the provider starts the deployment and waits (bounded) for it
* to reach a terminal state. Any change to the deployed version, strategy, or
* target creates a new deployment (a replacement). Use an all-at-once strategy
* (duration 0, bake 0) for a near-instant rollout.
*
* ### Deploying a Configuration
* **Example:** Deploy a Hosted Version
* ```typescript
* const deployment = yield* AppConfig.Deployment("Rollout", {
* applicationId: app.applicationId,
* environmentId: env.environmentId,
* deploymentStrategyId: strategy.deploymentStrategyId,
* configurationProfileId: profile.configurationProfileId,
* configurationVersion: String(version.versionNumber),
* });
* ```
*
* @resource
*/
export const Deployment = Resource<Deployment>("AWS.AppConfig.Deployment");
class DeploymentNotSettled extends Data.TaggedError("DeploymentNotSettled")<{
readonly deploymentNumber: number;
readonly state: string;
}> {}
const TERMINAL_STATES = new Set(["COMPLETE", "ROLLED_BACK", "REVERTED"]);
export const DeploymentProvider = () =>
Provider.effect(
Deployment,
Effect.gen(function* () {
const readDeployment = Effect.fn(function* (
applicationId: string,
environmentId: string,
deploymentNumber: number,
) {
return yield* appconfig
.getDeployment({
ApplicationId: applicationId,
EnvironmentId: environmentId,
DeploymentNumber: deploymentNumber,
})
.pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));
});
// Deployments roll out asynchronously; wait (bounded) for a terminal
// state. With an all-at-once strategy this settles in seconds.
const waitForSettled = Effect.fn(function* (
applicationId: string,
environmentId: string,
deploymentNumber: number,
) {
return yield* readDeployment(applicationId, environmentId, deploymentNumber).pipe(
Effect.flatMap((deployment) =>
deployment !== undefined && !TERMINAL_STATES.has(deployment.State ?? "")
? Effect.fail(
new DeploymentNotSettled({
deploymentNumber,
state: deployment.State ?? "",
}),
)
: Effect.succeed(deployment),
),
Effect.retry({
while: (e) => e instanceof DeploymentNotSettled,
schedule: Schedule.max([Schedule.fixed("3 seconds"), Schedule.recurs(40)]),
}),
);
});
return {
stables: ["applicationId", "environmentId", "deploymentNumber"],
// Deployments are immutable — any change starts a new deployment.
diff: Effect.fn(function* ({ olds, news }) {
if (!isResolved(news)) return undefined;
if (
olds !== undefined &&
(olds.applicationId !== news.applicationId ||
olds.environmentId !== news.environmentId ||
olds.deploymentStrategyId !== news.deploymentStrategyId ||
olds.configurationProfileId !== news.configurationProfileId ||
olds.configurationVersion !== news.configurationVersion)
) {
return { action: "replace" } as const;
}
}),
read: Effect.fn(function* ({ output }) {
if (output?.deploymentNumber === undefined) return undefined;
const deployment = yield* readDeployment(
output.applicationId,
output.environmentId,
output.deploymentNumber,
);
if (deployment?.DeploymentNumber === undefined) return undefined;
return {
applicationId: output.applicationId,
environmentId: output.environmentId,
deploymentNumber: deployment.DeploymentNumber,
configurationProfileId:
deployment.ConfigurationProfileId ?? output.configurationProfileId,
configurationVersion: deployment.ConfigurationVersion ?? output.configurationVersion,
state: deployment.State ?? "",
};
}),
reconcile: Effect.fn(function* ({ news, output, session }) {
// Observe — an interrupted create may already have started the
// deployment.
let observed =
output?.deploymentNumber !== undefined
? yield* readDeployment(
news.applicationId,
news.environmentId,
output.deploymentNumber,
)
: undefined;
// Ensure — start the deployment if it does not exist yet. A
// concurrent deployment on the same environment rejects with
// ConflictException; retry (bounded) until it clears.
if (observed?.DeploymentNumber === undefined) {
observed = yield* appconfig
.startDeployment({
ApplicationId: news.applicationId,
EnvironmentId: news.environmentId,
DeploymentStrategyId: news.deploymentStrategyId,
ConfigurationProfileId: news.configurationProfileId,
ConfigurationVersion: news.configurationVersion,
Description: news.description,
})
.pipe(
Effect.retry({
while: (e) => e._tag === "ConflictException",
schedule: Schedule.max([Schedule.fixed("3 seconds"), Schedule.recurs(20)]),
}),
);
}
const number = observed.DeploymentNumber!;
const settled = yield* waitForSettled(news.applicationId, news.environmentId, number);
yield* session.note(`deployment-${number}`);
return {
applicationId: news.applicationId,
environmentId: news.environmentId,
deploymentNumber: number,
configurationProfileId: news.configurationProfileId,
configurationVersion: news.configurationVersion,
state: settled?.State ?? observed.State ?? "",
};
}),
delete: Effect.fn(function* ({ output }) {
// A completed deployment is historical and cannot be deleted;
// stopDeployment only affects an in-progress rollout. Treat a
// "nothing to stop" rejection as success.
yield* appconfig
.stopDeployment({
ApplicationId: output.applicationId,
EnvironmentId: output.environmentId,
DeploymentNumber: output.deploymentNumber,
})
.pipe(
Effect.catchTag(
["ResourceNotFoundException", "BadRequestException"],
() => Effect.void,
),
);
}),
// Deployments are keyed under their parent environment.
list: () => Effect.succeed([]),
};
}),
);