import * as cloudfront from "@distilled.cloud/aws/cloudfront";
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 class InvalidationUnexpectedResponse extends Data.TaggedError(
"InvalidationUnexpectedResponse",
)<{
readonly message: string;
readonly cause?: unknown;
}> {}
export interface InvalidationProps {
/**
* Distribution to invalidate.
*/
distributionId: string;
/**
* Version string used as the invalidation caller reference. Change this value
* to trigger a new invalidation.
*/
version: string;
/**
* Paths to invalidate.
* @default ["/*"]
*/
paths?: string[];
/**
* Wait for the invalidation to complete.
* @default false
*/
wait?: boolean;
}
export interface Invalidation extends Resource<
"AWS.CloudFront.Invalidation",
InvalidationProps,
{
/**
* The identifier of the invalidation batch.
*/
invalidationId: string;
/**
* The distribution the invalidation ran against.
*/
distributionId: string;
/**
* The version prop that triggered this invalidation batch.
*/
version: string;
/**
* Current status of the invalidation (`InProgress` or `Completed`).
*/
status: string;
/**
* The path patterns that were invalidated.
*/
paths: string[];
/**
* When the invalidation batch was created.
*/
createTime: Date | undefined;
},
never,
Providers
> {}
/**
* A CloudFront cache invalidation request.
*
* `Invalidation` is a helper resource for website deployments that need to
* clear selected CloudFront cache paths after asset updates.
* ### Creating Invalidations
* **Example:** Invalidate The Entire Distribution
* ```typescript
* const invalidation = yield* Invalidation("WebsiteInvalidation", {
* distributionId: distribution.distributionId,
* version: files.version,
* });
* ```
*
* @resource
*/
export const Invalidation = Resource<Invalidation>("AWS.CloudFront.Invalidation");
const defaultPaths = ["/*"];
class InvalidationInProgress extends Data.TaggedError("InvalidationInProgress")<{
message: string;
}> {}
export const InvalidationProvider = () =>
Provider.effect(
Invalidation,
Effect.gen(function* () {
const waitForCompletion = Effect.fn(function* (
distributionId: string,
invalidationId: string,
) {
yield* Effect.logInfo(
`CloudFront Invalidation wait: polling ${invalidationId} for distribution ${distributionId}`,
);
return yield* cloudfront
.getInvalidation({
DistributionId: distributionId,
Id: invalidationId,
})
.pipe(
Effect.map((response) => response.Invalidation),
Effect.flatMap((invalidation) =>
invalidation?.Status === "Completed"
? Effect.gen(function* () {
yield* Effect.logInfo(
`CloudFront Invalidation wait: ${invalidationId} completed`,
);
return invalidation;
})
: Effect.gen(function* () {
yield* Effect.logInfo(
`CloudFront Invalidation wait: ${invalidationId} status=${invalidation?.Status ?? "unknown"}`,
);
return yield* new InvalidationInProgress({
message: `Invalidation ${invalidationId} is still in progress`,
});
}),
),
Effect.retry({
while: (error) => error._tag === "InvalidationInProgress",
schedule: Schedule.max([Schedule.fixed("2 seconds"), Schedule.recurs(120)]),
}),
);
});
const createInvalidation = Effect.fn(function* (props: InvalidationProps) {
yield* Effect.logInfo(
`CloudFront Invalidation create: distribution=${props.distributionId} version=${props.version} paths=${(props.paths ?? defaultPaths).length} wait=${props.wait ?? false}`,
);
const response = yield* cloudfront.createInvalidation({
DistributionId: props.distributionId,
InvalidationBatch: {
CallerReference: props.version,
Paths: {
Quantity: (props.paths ?? defaultPaths).length,
Items: props.paths ?? defaultPaths,
},
},
});
yield* Effect.logInfo(
`CloudFront Invalidation create: created ${response.Invalidation?.Id ?? "missing"} status=${response.Invalidation?.Status ?? "unknown"}`,
);
const invalidation = props.wait
? yield* waitForCompletion(props.distributionId, response.Invalidation?.Id!)
: response.Invalidation;
if (!invalidation?.Id) {
return yield* new InvalidationUnexpectedResponse({
message: "createInvalidation returned no invalidation",
});
}
return invalidation;
});
return {
stables: ["distributionId", "version"],
// Non-listable: an Invalidation is an ephemeral, immutable ledger entry
// keyed by {distributionId, invalidationId}. It completes on its own and
// cannot be deleted (`delete` is a no-op), so there is no persistent
// "current resource" to enumerate for nuke. `listInvalidations` only
// exposes historical, undeletable entries per distribution.
list: () => Effect.succeed([]),
diff: Effect.fn(function* ({ olds, news: _news }) {
if (!isResolved(_news)) return undefined;
const news = _news as typeof olds;
yield* Effect.logInfo(
`CloudFront Invalidation diff: oldDistribution=${olds.distributionId} newDistribution=${news.distributionId} oldVersion=${olds.version} newVersion=${news.version}`,
);
if (olds.distributionId !== news.distributionId || olds.version !== news.version) {
yield* Effect.logInfo(
`CloudFront Invalidation diff: replacing invalidation for distribution=${news.distributionId}`,
);
return { action: "replace" } as const;
}
}),
reconcile: Effect.fn(function* ({ news, output, session }) {
// An invalidation is an immutable ledger entry, not a mutable
// resource. If we already issued one for this distribution and
// version, return its attributes unchanged. `diff` only sees a
// version change when it is resolved at plan time; a version taken
// from an upstream output (e.g. `AssetDeployment.version`) is
// unresolved whenever that upstream changes, so the engine plans an
// update instead of a replace and lands here with the old output.
if (
output?.invalidationId &&
output.distributionId === news.distributionId &&
output.version === news.version
) {
yield* session.note(output.invalidationId);
return output;
}
// Ensure — issue the invalidation. CloudFront uses
// `CallerReference` (= `version`) for idempotency: the same
// version submitted twice returns the same invalidation.
const invalidation = yield* createInvalidation(news);
yield* Effect.logInfo(
`CloudFront Invalidation reconcile: storing ${invalidation.Id} for distribution=${news.distributionId}`,
);
yield* session.note(invalidation.Id);
return {
invalidationId: invalidation.Id,
distributionId: news.distributionId,
version: news.version,
status: invalidation.Status ?? "InProgress",
paths: news.paths ?? defaultPaths,
createTime: invalidation.CreateTime,
};
}),
delete: Effect.fn(function* () {}),
};
}),
);