import * as config from "@distilled.cloud/aws/config-service";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import { toWireDays } from "alchemy/Util/Duration";
import type * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";
import type { Providers } from "../Providers.ts";
export interface RetentionConfigurationProps {
/**
* How long AWS Config retains your recorded configuration items. Accepts
* any `Duration.Input` (e.g. `"90 days"`, `Duration.days(365)`); converted
* to whole days on the wire (`RetentionPeriodInDays`). AWS accepts between
* 30 days and 7 years (2557 days).
*/
retentionPeriod: Duration.Input;
}
export interface RetentionConfiguration extends Resource<
"AWS.Config.RetentionConfiguration",
RetentionConfigurationProps,
{
/** Name of the retention configuration. AWS always names it `default`. */
retentionConfigurationName: string;
/** The retention period in whole days. */
retentionPeriodInDays: number;
},
never,
Providers
> {}
/**
* The AWS Config retention configuration that controls how long AWS Config
* retains your recorded configuration items.
*
* AWS allows only **one** retention configuration per account per region and
* always names it `default` — treat this resource as an account-region
* singleton.
* ### Configuring Retention
* **Example:** Retain configuration items for one year
* ```typescript
* import * as Config from "@alchemy.run/aws/Config";
*
* const retention = yield* Config.RetentionConfiguration("Retention", {
* retentionPeriod: "365 days",
* });
* ```
*
* **Example:** Minimum retention
* ```typescript
* const retention = yield* Config.RetentionConfiguration("Retention", {
* retentionPeriod: "30 days",
* });
* ```
*
* @resource
*/
export const RetentionConfiguration = Resource<RetentionConfiguration>(
"AWS.Config.RetentionConfiguration",
);
export const RetentionConfigurationProvider = () =>
Provider.effect(
RetentionConfiguration,
Effect.gen(function* () {
// The API names the singleton object `default`; describe with no name
// filter returns it (or nothing).
const observeRetention = config.describeRetentionConfigurations({}).pipe(
Effect.map((r) => (r.RetentionConfigurations ?? []).at(0)),
Effect.catchTag("NoSuchRetentionConfigurationException", () => Effect.undefined),
);
const toAttrs = (retention: config.RetentionConfiguration) => ({
retentionConfigurationName: retention.Name,
retentionPeriodInDays: retention.RetentionPeriodInDays,
});
return RetentionConfiguration.Provider.of({
stables: ["retentionConfigurationName"],
list: () =>
config.describeRetentionConfigurations.items({}).pipe(
Stream.runCollect,
Effect.map((retentions) => Array.from(retentions).map(toAttrs)),
),
// Retention configurations are not taggable and AWS fixes the name to
// `default`, so there is no ownership marker — an existing retention
// configuration is treated as ours (singleton adoption), matching the
// DeliveryChannel convention.
read: Effect.fn(function* () {
const retention = yield* observeRetention;
return retention === undefined ? undefined : toAttrs(retention);
}),
reconcile: Effect.fn(function* ({ news, session }) {
const desiredDays = toWireDays(news.retentionPeriod)!;
// 1. OBSERVE — cloud state is authoritative.
const observed = yield* observeRetention;
// 2+3. ENSURE + SYNC — PutRetentionConfiguration is a full upsert
// of the account-region singleton; skip the API on no-op.
if (observed === undefined || observed.RetentionPeriodInDays !== desiredDays) {
yield* config.putRetentionConfiguration({
RetentionPeriodInDays: desiredDays,
});
}
const name = observed?.Name ?? "default";
yield* session.note(`${name} (${desiredDays} days)`);
return {
retentionConfigurationName: name,
retentionPeriodInDays: desiredDays,
};
}),
delete: Effect.fn(function* ({ output }) {
yield* config
.deleteRetentionConfiguration({
RetentionConfigurationName: output.retentionConfigurationName,
})
.pipe(Effect.catchTag("NoSuchRetentionConfigurationException", () => Effect.void));
}),
});
}),
);