import * as appconfig from "@distilled.cloud/aws/appconfig";
import { Unowned } from "alchemy/AdoptPolicy";
import { isResolved } from "alchemy/Diff";
import { createPhysicalName } from "alchemy/PhysicalName";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import { createInternalTags, hasAlchemyTags } from "alchemy/Tags";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";
import { AWSEnvironment } from "../Environment.ts";
import type { Providers } from "../Providers.ts";
import { environmentArn, readAppConfigTags, syncAppConfigTags } from "./internal.ts";
/**
* A CloudWatch alarm AppConfig monitors during a deployment. If the alarm
* fires while the configuration is rolling out, the deployment rolls back.
*/
export interface EnvironmentMonitor {
/** ARN of the CloudWatch alarm to monitor. */
alarmArn: string;
/** ARN of an IAM role AppConfig assumes to read the alarm's state. */
alarmRoleArn?: string;
}
export interface EnvironmentProps {
/**
* ID of the application this environment belongs to. Changing it replaces
* the environment.
*/
applicationId: string;
/**
* Name of the environment. Must be 1-64 characters. If omitted, a
* deterministic physical name is generated. Changing the name replaces the
* environment.
*/
environmentName?: string;
/**
* Description of the environment.
*/
description?: string;
/**
* CloudWatch alarms AppConfig monitors during deployments to this
* environment.
*/
monitors?: EnvironmentMonitor[];
/**
* User-defined tags for the environment.
*/
tags?: Record<string, string>;
}
export interface Environment extends Resource<
"AWS.AppConfig.Environment",
EnvironmentProps,
{
environmentId: string;
environmentName: string;
applicationId: string;
environmentArn: string;
state: string;
},
never,
Providers
> {}
/**
* An AWS AppConfig environment — a deployment group of AppConfig targets
* (e.g. `Beta`, `Production`) within an application. CloudWatch alarms
* attached via `monitors` trigger an automatic rollback if they fire during a
* deployment.
*
* ### Creating an Environment
* **Example:** Basic Environment
* ```typescript
* const app = yield* AppConfig.Application("MyApp", {});
* const env = yield* AppConfig.Environment("Prod", {
* applicationId: app.applicationId,
* });
* ```
*
* **Example:** Environment with Rollback Alarm
* ```typescript
* const env = yield* AppConfig.Environment("Prod", {
* applicationId: app.applicationId,
* monitors: [{ alarmArn: alarm.alarmArn, alarmRoleArn: role.roleArn }],
* });
* ```
*
* @resource
*/
export const Environment = Resource<Environment>("AWS.AppConfig.Environment");
const toWireMonitors = (
monitors: EnvironmentMonitor[] | undefined,
): appconfig.Monitor[] | undefined =>
monitors?.map((m) => ({
AlarmArn: m.alarmArn,
AlarmRoleArn: m.alarmRoleArn,
}));
export const EnvironmentProvider = () =>
Provider.effect(
Environment,
Effect.gen(function* () {
const toName = (id: string, props: Partial<EnvironmentProps>) =>
props.environmentName
? Effect.succeed(props.environmentName)
: createPhysicalName({ id, maxLength: 64 });
const readEnvironment = Effect.fn(function* (applicationId: string, environmentId: string) {
return yield* appconfig
.getEnvironment({
ApplicationId: applicationId,
EnvironmentId: environmentId,
})
.pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));
});
const findByName = Effect.fn(function* (applicationId: string, name: string) {
const envs = yield* appconfig.listEnvironments.pages({ ApplicationId: applicationId }).pipe(
Stream.runCollect,
Effect.map((chunk) => Array.from(chunk).flatMap((page) => page.Items ?? [])),
Effect.catchTag("ResourceNotFoundException", () =>
Effect.succeed([] as appconfig.Environment[]),
),
);
return envs.find((e) => e.Name === name);
});
return {
stables: ["environmentId", "environmentName", "applicationId", "environmentArn"],
diff: Effect.fn(function* ({ id, olds, news }) {
if (!isResolved(news)) return undefined;
if ((yield* toName(id, olds ?? {})) !== (yield* toName(id, news ?? {}))) {
return { action: "replace" } as const;
}
if ((olds?.applicationId ?? undefined) !== news?.applicationId) {
return { action: "replace" } as const;
}
}),
read: Effect.fn(function* ({ id, olds, output }) {
const { accountId, region } = yield* AWSEnvironment.current;
const applicationId = output?.applicationId ?? olds?.applicationId;
if (applicationId === undefined) return undefined;
const env = output?.environmentId
? yield* readEnvironment(applicationId, output.environmentId)
: yield* findByName(applicationId, yield* toName(id, olds ?? {}));
if (env?.Id === undefined) return undefined;
const arn = environmentArn(region, accountId, applicationId, env.Id);
const attrs = {
environmentId: env.Id,
environmentName: env.Name!,
applicationId,
environmentArn: arn,
state: env.State ?? "",
};
const tags = yield* readAppConfigTags(arn);
return (yield* hasAlchemyTags(id, tags)) ? attrs : Unowned(attrs);
}),
reconcile: Effect.fn(function* ({ id, news, output, session }) {
const { accountId, region } = yield* AWSEnvironment.current;
const applicationId = news.applicationId;
const name = output?.environmentName ?? (yield* toName(id, news));
const internalTags = yield* createInternalTags(id);
const desiredTags = { ...internalTags, ...news.tags };
// 1. Observe.
let observed = output?.environmentId
? yield* readEnvironment(applicationId, output.environmentId)
: undefined;
if (observed === undefined) {
observed = yield* findByName(applicationId, name);
}
// 2. Ensure.
if (observed?.Id === undefined) {
observed = yield* appconfig.createEnvironment({
ApplicationId: applicationId,
Name: name,
Description: news.description,
Monitors: toWireMonitors(news.monitors),
Tags: desiredTags,
});
} else {
// 3. Sync — description and monitors are mutable in place.
observed = yield* appconfig.updateEnvironment({
ApplicationId: applicationId,
EnvironmentId: observed.Id,
Description: news.description,
Monitors: toWireMonitors(news.monitors),
});
}
const arn = environmentArn(region, accountId, applicationId, observed.Id!);
// 3b. Sync tags.
yield* syncAppConfigTags(arn, desiredTags);
yield* session.note(name);
return {
environmentId: observed.Id!,
environmentName: observed.Name ?? name,
applicationId,
environmentArn: arn,
state: observed.State ?? "",
};
}),
delete: Effect.fn(function* ({ output }) {
yield* appconfig
.deleteEnvironment({
ApplicationId: output.applicationId,
EnvironmentId: output.environmentId,
})
.pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.void));
}),
// Environments are keyed under their parent application, so
// enumeration walks every application and lists its environments.
// An application cannot be deleted while environments exist under
// it, so nuke needs these enumerated as first-class resources.
list: () =>
Effect.gen(function* () {
const { accountId, region } = yield* AWSEnvironment.current;
const apps = yield* appconfig.listApplications.pages({}).pipe(
Stream.runCollect,
Effect.map((chunk) => Array.from(chunk).flatMap((page) => page.Items ?? [])),
);
const results: {
environmentId: string;
environmentName: string;
applicationId: string;
environmentArn: string;
state: string;
}[] = [];
for (const app of apps) {
if (app.Id === undefined) continue;
const envs = yield* appconfig.listEnvironments.pages({ ApplicationId: app.Id }).pipe(
Stream.runCollect,
Effect.map((chunk) => Array.from(chunk).flatMap((page) => page.Items ?? [])),
// The application may be deleted between the two calls.
Effect.catchTag("ResourceNotFoundException", () =>
Effect.succeed([] as appconfig.Environment[]),
),
);
for (const env of envs) {
if (env.Id === undefined || env.Name === undefined) continue;
results.push({
environmentId: env.Id,
environmentName: env.Name,
applicationId: app.Id,
environmentArn: environmentArn(region, accountId, app.Id, env.Id),
state: env.State ?? "",
});
}
}
return results;
}),
};
}),
);