import * as cloudfront from "@distilled.cloud/aws/cloudfront";
import { isResolved } from "alchemy/Diff";
import { createPhysicalName } from "alchemy/PhysicalName";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import * as Data from "effect/Data";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Schedule from "effect/Schedule";
import type { Providers } from "../Providers.ts";
export class FunctionUnexpectedResponse extends Data.TaggedError("FunctionUnexpectedResponse")<{
readonly message: string;
readonly cause?: unknown;
}> {}
export interface FunctionProps {
/**
* CloudFront Function name. If omitted, a deterministic name is generated.
*/
name?: string;
/**
* CloudFront Function runtime.
* @default "cloudfront-js-2.0"
*/
runtime?: cloudfront.FunctionRuntime;
/**
* Optional function comment.
*/
comment?: string;
/**
* JavaScript source code for the function.
*/
code: string;
/**
* Optional associated KeyValueStore ARNs.
*/
keyValueStoreArns?: string[];
}
export interface Function extends Resource<
"AWS.CloudFront.Function",
FunctionProps,
{
/**
* CloudFront function ARN.
*/
functionArn: string;
/**
* Function name.
*/
functionName: string;
/**
* Runtime currently configured for the function.
*/
runtime: cloudfront.FunctionRuntime;
/**
* Current comment.
*/
comment: string;
/**
* Deployment stage for the function.
*/
stage: cloudfront.FunctionStage;
/**
* Last modified time.
*/
lastModifiedTime: Date | undefined;
/**
* Latest entity tag for update/delete operations.
*/
etag: string | undefined;
/**
* Associated KeyValueStore ARNs.
*/
keyValueStoreArns: string[];
},
never,
Providers
> {}
/**
* A CloudFront Function for viewer request and response customization.
*
* CloudFront Functions are lightweight JavaScript handlers that run at the
* edge and can be attached to distribution cache behaviors.
* ### Creating Functions
* **Example:** Viewer Request Function
* ```typescript
* const fn = yield* Function("RouterRequestFunction", {
* code: `
* async function handler(event) {
* event.request.headers["x-forwarded-host"] = {
* value: event.request.headers.host.value,
* };
* return event.request;
* }
* `,
* });
* ```
*
* @resource
*/
export const Function = Resource<Function>("AWS.CloudFront.Function");
export const FunctionProvider = () =>
Provider.effect(
Function,
Effect.gen(function* () {
const describe = Effect.fn(function* (name: string, stage?: cloudfront.FunctionStage) {
return yield* cloudfront
.describeFunction({
Name: name,
Stage: stage,
})
.pipe(Effect.catchTag("NoSuchFunctionExists", () => Effect.undefined));
});
const getCurrent = Effect.fn(function* (name: string) {
const live = yield* describe(name, "LIVE");
if (live?.FunctionSummary) {
return live;
}
return yield* describe(name, "DEVELOPMENT");
});
const getDevelopmentEtag = Effect.fn(function* (name: string) {
const current = yield* describe(name, "DEVELOPMENT");
return current?.ETag;
});
const publish = Effect.fn(function* (name: string, etag: string | undefined) {
if (!etag) {
return yield* new FunctionUnexpectedResponse({
message: `CloudFront Function '${name}' is missing an ETag for publish`,
});
}
yield* cloudfront.publishFunction({
Name: name,
IfMatch: etag,
});
return yield* describe(name, "LIVE");
});
return {
stables: ["functionArn", "functionName"],
// CloudFront is global; listFunctions enumerates every function in the
// account. It is non-paginated in distilled but uses Marker/NextMarker,
// so we page manually until NextMarker is absent. All CloudFront
// functions are custom (no AWS-managed ones), so every item is ours.
list: () =>
Effect.gen(function* () {
const items: Function["Attributes"][] = [];
let marker: string | undefined = undefined;
do {
const listed: cloudfront.ListFunctionsResult = yield* cloudfront.listFunctions({
Marker: marker,
});
for (const summary of listed.FunctionList?.Items ?? []) {
items.push(toAttrs(summary, undefined, summary.Name ?? ""));
}
marker = listed.FunctionList?.NextMarker;
} while (marker);
return items;
}),
diff: Effect.fn(function* ({ id, olds, news: _news }) {
if (!isResolved(_news)) return undefined;
const news = _news as typeof olds;
if ((yield* createName(id, olds ?? {})) !== (yield* createName(id, news))) {
return { action: "replace" } as const;
}
}),
read: Effect.fn(function* ({ id, olds, output }) {
const name = output?.functionName ?? (yield* createName(id, olds ?? {}));
const current = yield* getCurrent(name);
if (!current?.FunctionSummary) {
return undefined;
}
return toAttrs(current.FunctionSummary, current.ETag, name);
}),
reconcile: Effect.fn(function* ({ id, news, output, session }) {
const name = output?.functionName ?? (yield* createName(id, news));
// Observe — describe the function (LIVE stage preferred,
// DEVELOPMENT fallback). We don't trust `output` because the
// function may have been deleted out-of-band.
const observedDevelopment = yield* describe(name, "DEVELOPMENT");
// Ensure — create the function if it's missing. Tolerate
// `FunctionAlreadyExists` as a race with a peer reconciler. The
// newly created function lives in DEVELOPMENT; we publish it to
// LIVE below, in the same flow that handles already-existing
// functions.
const createDevelopmentFunction = Effect.gen(function* () {
const created = yield* cloudfront
.createFunction({
Name: name,
FunctionConfig: {
Comment: news.comment ?? "",
Runtime: news.runtime ?? "cloudfront-js-2.0",
KeyValueStoreAssociations: toKvAssociations(news.keyValueStoreArns),
},
FunctionCode: new TextEncoder().encode(news.code),
})
.pipe(
Effect.catchTag("FunctionAlreadyExists", () =>
describe(name, "DEVELOPMENT").pipe(
Effect.flatMap((existing) =>
existing
? Effect.succeed(existing)
: Effect.die(
`CloudFront Function '${name}' already exists but could not be recovered`,
),
),
),
),
Effect.retry({
while: (error) =>
error._tag === "InvalidArgument" && isKeyValueStoreAssociationPending(error),
schedule: cappedCloudFrontRetrySchedule,
}),
);
return created.ETag;
});
const developmentEtag = observedDevelopment
? observedDevelopment.ETag
: yield* createDevelopmentFunction;
// Sync — push desired config/code to DEVELOPMENT when the
// function already existed. Skip when we just created it (the
// creation already used the desired config).
let etagToPublish = developmentEtag;
if (observedDevelopment) {
const updated = yield* cloudfront
.updateFunction({
Name: name,
IfMatch: observedDevelopment.ETag!,
FunctionConfig: {
Comment: news.comment ?? "",
Runtime:
news.runtime ??
observedDevelopment.FunctionSummary?.FunctionConfig.Runtime ??
"cloudfront-js-2.0",
KeyValueStoreAssociations: toKvAssociations(news.keyValueStoreArns),
},
FunctionCode: new TextEncoder().encode(news.code),
})
.pipe(
Effect.retry({
while: (error) =>
error._tag === "InvalidArgument" && isKeyValueStoreAssociationPending(error),
schedule: cappedCloudFrontRetrySchedule,
}),
);
etagToPublish = updated.ETag;
}
// Publish DEVELOPMENT → LIVE so consumers see the desired code.
const live = yield* publish(name, etagToPublish);
if (!live?.FunctionSummary) {
return yield* Effect.die("publishFunction returned no function summary");
}
yield* session.note(name);
return toAttrs(live.FunctionSummary, live.ETag, name);
}),
delete: Effect.fn(function* ({ output }) {
yield* Effect.gen(function* () {
const developmentEtag = yield* getDevelopmentEtag(output.functionName);
if (!developmentEtag) {
yield* Effect.logInfo(
`CloudFront Function delete: ${output.functionName} already absent`,
);
return;
}
yield* Effect.logInfo(
`CloudFront Function delete: deleting ${output.functionName} stage=DEVELOPMENT etag=${developmentEtag}`,
);
yield* cloudfront.deleteFunction({
Name: output.functionName,
IfMatch: developmentEtag,
});
}).pipe(
Effect.catchTag("NoSuchFunctionExists", () => Effect.void),
Effect.tapError((error) =>
isFunctionDeletePending(error)
? Effect.logInfo(
`CloudFront Function delete: ${output.functionName} not ready yet (${error._tag}), retrying with capped exponential backoff`,
)
: Effect.logError(
`CloudFront Function delete: ${output.functionName} failed with ${String(error)}`,
),
),
Effect.retry({
while: isFunctionDeletePending,
schedule: cappedCloudFrontRetrySchedule,
}),
);
}),
};
}),
);
const isFunctionDeletePending = (error: {
_tag?: string;
}): error is cloudfront.FunctionInUse | cloudfront.PreconditionFailed =>
error._tag === "FunctionInUse" || error._tag === "PreconditionFailed";
const isKeyValueStoreAssociationPending = (error: { message?: string }) => {
const message = error.message ?? "";
return (
message.includes("KeyValueStoreAssociationArn") &&
message.includes("cannot be associated before the resource is provisioned")
);
};
const cappedCloudFrontRetrySchedule = Schedule.max([
Schedule.exponential("100 millis"),
Schedule.recurs(24),
]).pipe(
Schedule.modifyDelay(({ duration }) =>
Effect.succeed(
Duration.isGreaterThan(duration, Duration.seconds(2)) ? Duration.seconds(2) : duration,
),
),
);
const createName = (id: string, props: FunctionProps) =>
props.name
? Effect.succeed(props.name)
: createPhysicalName({
id,
maxLength: 64,
lowercase: true,
});
const toKvAssociations = (
arns: string[] | undefined,
): cloudfront.KeyValueStoreAssociations | undefined =>
arns && arns.length > 0
? {
Quantity: arns.length,
Items: arns.map((KeyValueStoreARN) => ({ KeyValueStoreARN })),
}
: undefined;
const toAttrs = (
summary: cloudfront.FunctionSummary,
etag: string | undefined,
fallbackName: string,
): Function["Attributes"] => ({
functionArn: summary.FunctionMetadata.FunctionARN,
functionName: summary.Name || fallbackName,
runtime: summary.FunctionConfig.Runtime,
comment: summary.FunctionConfig.Comment ?? "",
stage: summary.FunctionMetadata.Stage ?? "DEVELOPMENT",
lastModifiedTime: summary.FunctionMetadata.LastModifiedTime,
etag,
keyValueStoreArns:
summary.FunctionConfig.KeyValueStoreAssociations?.Items?.flatMap((item) =>
item.KeyValueStoreARN ? [item.KeyValueStoreARN] : [],
) ?? [],
});