@kensio/yulin 1.20.16 → 1.21.0

package/dist/service/cloudfront/command/invalidation/sim-cf-create-invalidation.d.ts

@@ -0,0 +1,28 @@
+import type { SimAwsCaller } from "../../../aws/caller/sim-aws-caller.js";
+import type { SimCfInvalidationAccess } from "./sim-cf-invalidation-access.js";
+import type { SimCreateInvalidationCommand, SimCreateInvalidationCommandOutput } from "./sim-cf-invalidation-command.types.js";
+/**
+ * Simulated CloudFront CreateInvalidation command.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudfront/command/CreateInvalidationCommand/
+ */
+export declare class SimCfCreateInvalidation {
+    private readonly access;
+    private static readonly action;
+    constructor(access: SimCfInvalidationAccess);
+    /**
+     * Clear what a batch of paths names. The next request for one of them
+     * reaches the Origin.
+     *
+     * The entries go as the invalidation is created. Real CloudFront clears each
+     * point of presence over the following seconds, and a test waiting for that
+     * before asking again would be waiting on the simulator.
+     */
+    handle(command: SimCreateInvalidationCommand, options?: {
+        readonly caller?: SimAwsCaller;
+    }): Promise<SimCreateInvalidationCommandOutput>;
+    /**
+     * Create an invalidation, clear what it names, and start it running.
+     */
+    private invalidate;
+}

package/dist/service/cloudfront/command/invalidation/sim-cf-create-invalidation.js

@@ -0,0 +1,59 @@
+import { assertDefined } from "../../../../util/type-guard/defined.js";
+import { SimCfInvalidation } from "../../invalidation/sim-cf-invalidation.js";
+import { simCfInvalidationLocation, simCfInvalidationView, } from "../../invalidation/sim-cf-invalidation-view.js";
+import { simCfRepeatedInvalidation } from "../../invalidation/sim-cf-repeated-invalidation.js";
+import { assertConsistentQuantity } from "../sim-cf-list-quantity.js";
+/**
+ * Simulated CloudFront CreateInvalidation command.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudfront/command/CreateInvalidationCommand/
+ */
+export class SimCfCreateInvalidation {
+    access;
+    static action = "cloudfront:CreateInvalidation";
+    constructor(access) {
+        this.access = access;
+    }
+    /**
+     * Clear what a batch of paths names. The next request for one of them
+     * reaches the Origin.
+     *
+     * The entries go as the invalidation is created. Real CloudFront clears each
+     * point of presence over the following seconds, and a test waiting for that
+     * before asking again would be waiting on the simulator.
+     */
+    async handle(command, options) {
+        const batch = command.input.InvalidationBatch;
+        assertDefined(batch, "CreateInvalidationCommand.InvalidationBatch");
+        const callerReference = batch.CallerReference;
+        assertDefined(callerReference, "CreateInvalidationCommand.InvalidationBatch.CallerReference");
+        assertConsistentQuantity("InvalidationBatch.Paths", batch.Paths);
+        await this.access.background.sequence();
+        const distribution = this.access.authorizedDistribution(SimCfCreateInvalidation.action, command.input.DistributionId, options?.caller);
+        const paths = batch.Paths?.Items ?? [];
+        const invalidation = simCfRepeatedInvalidation(distribution, callerReference, paths) ??
+            this.invalidate(distribution, callerReference, paths);
+        return {
+            Location: simCfInvalidationLocation(distribution.distributionId, invalidation.invalidationId),
+            Invalidation: simCfInvalidationView(invalidation),
+            $metadata: {},
+        };
+    }
+    /**
+     * Create an invalidation, clear what it names, and start it running.
+     */
+    invalidate(distribution, callerReference, paths) {
+        const invalidation = new SimCfInvalidation({
+            invalidationId: distribution.invalidations.allocateInvalidationId(),
+            callerReference,
+            paths,
+            createTime: this.access.background.now(),
+        });
+        distribution.invalidations.add(invalidation);
+        distribution.cache.clearPaths(paths);
+        // The invalidation reaches Completed in the background, the way a
+        // Distribution reaches Deployed.
+        this.access.background.schedule(async () => invalidation.completeInvalidation());
+        return invalidation;
+    }
+}

package/dist/service/cloudfront/command/invalidation/sim-cf-get-invalidation.d.ts

@@ -0,0 +1,19 @@
+import type { SimAwsCaller } from "../../../aws/caller/sim-aws-caller.js";
+import type { SimCfInvalidationAccess } from "./sim-cf-invalidation-access.js";
+import type { SimGetInvalidationCommand, SimGetInvalidationCommandOutput } from "./sim-cf-invalidation-command.types.js";
+/**
+ * Simulated CloudFront GetInvalidation command.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudfront/command/GetInvalidationCommand/
+ */
+export declare class SimCfGetInvalidation {
+    private readonly access;
+    private static readonly action;
+    constructor(access: SimCfInvalidationAccess);
+    /**
+     * Read one invalidation of a Distribution back.
+     */
+    handle(command: SimGetInvalidationCommand, options?: {
+        readonly caller?: SimAwsCaller;
+    }): Promise<SimGetInvalidationCommandOutput>;
+}

package/dist/service/cloudfront/command/invalidation/sim-cf-get-invalidation.js

@@ -0,0 +1,32 @@
+import { assertDefined } from "../../../../util/type-guard/defined.js";
+import { SimCloudFrontNoSuchInvalidation } from "../../error/sim-cf-invalidation.error.js";
+import { simCfInvalidationView } from "../../invalidation/sim-cf-invalidation-view.js";
+/**
+ * Simulated CloudFront GetInvalidation command.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudfront/command/GetInvalidationCommand/
+ */
+export class SimCfGetInvalidation {
+    access;
+    static action = "cloudfront:GetInvalidation";
+    constructor(access) {
+        this.access = access;
+    }
+    /**
+     * Read one invalidation of a Distribution back.
+     */
+    async handle(command, options) {
+        const invalidationId = command.input.Id;
+        assertDefined(invalidationId, "GetInvalidationCommand.Id");
+        await this.access.background.sequence();
+        const distribution = this.access.authorizedDistribution(SimCfGetInvalidation.action, command.input.DistributionId, options?.caller);
+        const invalidation = distribution.invalidations.byId(invalidationId);
+        if (invalidation === undefined) {
+            throw new SimCloudFrontNoSuchInvalidation(`No sim CloudFront invalidation with ID ${invalidationId} on Distribution ${distribution.distributionId}`);
+        }
+        return {
+            Invalidation: simCfInvalidationView(invalidation),
+            $metadata: {},
+        };
+    }
+}

package/dist/service/cloudfront/command/invalidation/sim-cf-invalidation-access.d.ts

@@ -0,0 +1,36 @@
+import type { BackgroundScheduler } from "../../../../util/background/background.js";
+import type { SimAwsCaller } from "../../../aws/caller/sim-aws-caller.js";
+import type { SimAwsAccountId } from "../../../aws/sim-aws-account.js";
+import type { SimIamInterServiceAuthZ } from "../../../iam/authorize/sim-iam-inter-service-auth-z.js";
+import type { SimCloudFrontDistribution, SimCloudFrontDistributionId } from "../../distribution/sim-cloudfront-distribution.js";
+interface SimCfInvalidationAccessProperties {
+    readonly accountId: SimAwsAccountId;
+    readonly distributions: Map<SimCloudFrontDistributionId, SimCloudFrontDistribution>;
+    readonly iam: SimIamInterServiceAuthZ;
+    readonly background: BackgroundScheduler;
+}
+/**
+ * What every invalidation command needs: the Distributions, IAM, and the
+ * clock.
+ *
+ * The three commands all name a Distribution, authorize against its ARN and
+ * resolve it the same way, so that happens here once rather than in each of
+ * them.
+ */
+export declare class SimCfInvalidationAccess {
+    readonly background: BackgroundScheduler;
+    private readonly accountId;
+    private readonly distributions;
+    private readonly iam;
+    constructor(properties: SimCfInvalidationAccessProperties);
+    /**
+     * Resolve the Distribution an invalidation command names, having authorized
+     * the action against its ARN.
+     *
+     * The ARN is built from the ID the caller gave, so authorization happens
+     * before the Distribution map is read and an unauthorized caller learns
+     * nothing about which IDs exist.
+     */
+    authorizedDistribution(action: string, distributionId: string | undefined, caller?: SimAwsCaller): SimCloudFrontDistribution;
+}
+export {};

package/dist/service/cloudfront/command/invalidation/sim-cf-invalidation-access.js

@@ -0,0 +1,45 @@
+import { assertDefined } from "../../../../util/type-guard/defined.js";
+import { SimCloudFrontNoSuchDistribution } from "../../error/sim-cloudfront.error.js";
+import { simCfAuthorize } from "../../sim-cf-authorize.js";
+/**
+ * What every invalidation command needs: the Distributions, IAM, and the
+ * clock.
+ *
+ * The three commands all name a Distribution, authorize against its ARN and
+ * resolve it the same way, so that happens here once rather than in each of
+ * them.
+ */
+export class SimCfInvalidationAccess {
+    background;
+    accountId;
+    distributions;
+    iam;
+    constructor(properties) {
+        this.accountId = properties.accountId;
+        this.distributions = properties.distributions;
+        this.iam = properties.iam;
+        this.background = properties.background;
+    }
+    /**
+     * Resolve the Distribution an invalidation command names, having authorized
+     * the action against its ARN.
+     *
+     * The ARN is built from the ID the caller gave, so authorization happens
+     * before the Distribution map is read and an unauthorized caller learns
+     * nothing about which IDs exist.
+     */
+    authorizedDistribution(action, distributionId, caller) {
+        assertDefined(distributionId, `${action} DistributionId`);
+        simCfAuthorize({
+            iam: this.iam,
+            action,
+            resource: `arn:aws:cloudfront::${this.accountId}:distribution/${distributionId}`,
+            caller,
+        });
+        const distribution = this.distributions.get(distributionId);
+        if (distribution === undefined) {
+            throw new SimCloudFrontNoSuchDistribution(`No sim CloudFront Distribution with ID ${distributionId}`);
+        }
+        return distribution;
+    }
+}

package/dist/service/cloudfront/command/invalidation/sim-cf-invalidation-command.types.d.ts

@@ -0,0 +1,80 @@
+import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
+import type { SimCfInvalidationSummaryView, SimCfInvalidationView } from "../../invalidation/sim-cf-invalidation-view.js";
+/**
+ * Minimal structural sim CloudFront invalidation batch, as a caller sends it.
+ */
+export interface SimCfInvalidationBatchInput {
+    readonly CallerReference?: string | undefined;
+    readonly Paths?: {
+        readonly Quantity?: number | undefined;
+        readonly Items?: readonly string[] | undefined;
+    } | undefined;
+}
+/**
+ * Minimal structural sim CloudFront CreateInvalidation command.
+ */
+export interface SimCreateInvalidationCommand {
+    readonly input: SimCreateInvalidationCommandInput;
+}
+/**
+ * Minimal structural sim CloudFront CreateInvalidation input.
+ */
+export interface SimCreateInvalidationCommandInput {
+    readonly DistributionId?: string | undefined;
+    readonly InvalidationBatch?: SimCfInvalidationBatchInput | undefined;
+}
+/**
+ * Minimal structural sim CloudFront CreateInvalidation output.
+ */
+export interface SimCreateInvalidationCommandOutput {
+    readonly Location?: string | undefined;
+    readonly Invalidation?: SimCfInvalidationView | undefined;
+    readonly $metadata: SimResponseMetadata;
+}
+/**
+ * Minimal structural sim CloudFront GetInvalidation command.
+ */
+export interface SimGetInvalidationCommand {
+    readonly input: SimGetInvalidationCommandInput;
+}
+/**
+ * Minimal structural sim CloudFront GetInvalidation input.
+ */
+export interface SimGetInvalidationCommandInput {
+    readonly DistributionId?: string | undefined;
+    readonly Id?: string | undefined;
+}
+/**
+ * Minimal structural sim CloudFront GetInvalidation output.
+ */
+export interface SimGetInvalidationCommandOutput {
+    readonly Invalidation?: SimCfInvalidationView | undefined;
+    readonly $metadata: SimResponseMetadata;
+}
+/**
+ * Minimal structural sim CloudFront ListInvalidations command.
+ */
+export interface SimListInvalidationsCommand {
+    readonly input: SimListInvalidationsCommandInput;
+}
+/**
+ * Minimal structural sim CloudFront ListInvalidations input.
+ */
+export interface SimListInvalidationsCommandInput {
+    readonly DistributionId?: string | undefined;
+    readonly Marker?: string | undefined;
+    readonly MaxItems?: number | undefined;
+}
+/**
+ * Minimal structural sim CloudFront ListInvalidations output.
+ */
+export interface SimListInvalidationsCommandOutput {
+    readonly InvalidationList?: {
+        readonly Marker: string;
+        readonly MaxItems: number;
+        readonly IsTruncated: boolean;
+        readonly Quantity: number;
+        readonly Items: readonly SimCfInvalidationSummaryView[];
+    } | undefined;
+    readonly $metadata: SimResponseMetadata;
+}

package/dist/service/cloudfront/command/invalidation/sim-cf-invalidation-command.types.js

@@ -0,0 +1 @@
+export {};

package/dist/service/cloudfront/command/invalidation/sim-cf-invalidation-commands.d.ts

@@ -0,0 +1,39 @@
+import type { BackgroundScheduler } from "../../../../util/background/background.js";
+import type { SimAwsCaller } from "../../../aws/caller/sim-aws-caller.js";
+import type { SimAwsAccountId } from "../../../aws/sim-aws-account.js";
+import type { SimIamInterServiceAuthZ } from "../../../iam/authorize/sim-iam-inter-service-auth-z.js";
+import type { SimCloudFrontDistribution, SimCloudFrontDistributionId } from "../../distribution/sim-cloudfront-distribution.js";
+import type { SimCreateInvalidationCommand, SimCreateInvalidationCommandOutput, SimGetInvalidationCommand, SimGetInvalidationCommandOutput, SimListInvalidationsCommand, SimListInvalidationsCommandOutput } from "./sim-cf-invalidation-command.types.js";
+interface SimCfInvalidationCommandsProperties {
+    readonly accountId: SimAwsAccountId;
+    readonly distributions: Map<SimCloudFrontDistributionId, SimCloudFrontDistribution>;
+    readonly iam: SimIamInterServiceAuthZ;
+    readonly background: BackgroundScheduler;
+}
+interface InvalidationRequestOptions {
+    readonly caller?: SimAwsCaller;
+}
+/**
+ * The invalidation commands on the CloudFront client.
+ *
+ * They are grouped here, the way the Function commands are, because all three
+ * work on state a Distribution holds of its own and share the lookup that
+ * reaches it.
+ */
+export declare class SimCfInvalidationCommands {
+    private readonly access;
+    constructor(properties: SimCfInvalidationCommandsProperties);
+    /**
+     * Handle a Create Invalidation Command from the SDK.
+     */
+    createInvalidation(command: SimCreateInvalidationCommand, options?: InvalidationRequestOptions): Promise<SimCreateInvalidationCommandOutput>;
+    /**
+     * Handle a Get Invalidation Command from the SDK.
+     */
+    getInvalidation(command: SimGetInvalidationCommand, options?: InvalidationRequestOptions): Promise<SimGetInvalidationCommandOutput>;
+    /**
+     * Handle a List Invalidations Command from the SDK.
+     */
+    listInvalidations(command: SimListInvalidationsCommand, options?: InvalidationRequestOptions): Promise<SimListInvalidationsCommandOutput>;
+}
+export {};

package/dist/service/cloudfront/command/invalidation/sim-cf-invalidation-commands.js

@@ -0,0 +1,35 @@
+import { SimCfCreateInvalidation } from "./sim-cf-create-invalidation.js";
+import { SimCfGetInvalidation } from "./sim-cf-get-invalidation.js";
+import { SimCfInvalidationAccess } from "./sim-cf-invalidation-access.js";
+import { SimCfListInvalidations } from "./sim-cf-list-invalidations.js";
+/**
+ * The invalidation commands on the CloudFront client.
+ *
+ * They are grouped here, the way the Function commands are, because all three
+ * work on state a Distribution holds of its own and share the lookup that
+ * reaches it.
+ */
+export class SimCfInvalidationCommands {
+    access;
+    constructor(properties) {
+        this.access = new SimCfInvalidationAccess(properties);
+    }
+    /**
+     * Handle a Create Invalidation Command from the SDK.
+     */
+    async createInvalidation(command, options) {
+        return await new SimCfCreateInvalidation(this.access).handle(command, options);
+    }
+    /**
+     * Handle a Get Invalidation Command from the SDK.
+     */
+    async getInvalidation(command, options) {
+        return await new SimCfGetInvalidation(this.access).handle(command, options);
+    }
+    /**
+     * Handle a List Invalidations Command from the SDK.
+     */
+    async listInvalidations(command, options) {
+        return await new SimCfListInvalidations(this.access).handle(command, options);
+    }
+}

package/dist/service/cloudfront/command/invalidation/sim-cf-list-invalidations.d.ts

@@ -0,0 +1,23 @@
+import type { SimAwsCaller } from "../../../aws/caller/sim-aws-caller.js";
+import type { SimCfInvalidationAccess } from "./sim-cf-invalidation-access.js";
+import type { SimListInvalidationsCommand, SimListInvalidationsCommandOutput } from "./sim-cf-invalidation-command.types.js";
+/**
+ * Simulated CloudFront ListInvalidations command.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudfront/command/ListInvalidationsCommand/
+ */
+export declare class SimCfListInvalidations {
+    private readonly access;
+    private static readonly action;
+    constructor(access: SimCfInvalidationAccess);
+    /**
+     * List a Distribution's invalidations, most recently created first.
+     *
+     * The whole list comes back. `Marker` and `MaxItems` are the paging every
+     * other simulated listing leaves out, so the answer is never truncated and
+     * carries no `NextMarker`.
+     */
+    handle(command: SimListInvalidationsCommand, options?: {
+        readonly caller?: SimAwsCaller;
+    }): Promise<SimListInvalidationsCommandOutput>;
+}

package/dist/service/cloudfront/command/invalidation/sim-cf-list-invalidations.js

@@ -0,0 +1,39 @@
+import { simCfInvalidationSummary } from "../../invalidation/sim-cf-invalidation-view.js";
+/**
+ * What CloudFront reports as `MaxItems` for a listing that asks for none.
+ */
+const defaultMaxItems = 100;
+/**
+ * Simulated CloudFront ListInvalidations command.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudfront/command/ListInvalidationsCommand/
+ */
+export class SimCfListInvalidations {
+    access;
+    static action = "cloudfront:ListInvalidations";
+    constructor(access) {
+        this.access = access;
+    }
+    /**
+     * List a Distribution's invalidations, most recently created first.
+     *
+     * The whole list comes back. `Marker` and `MaxItems` are the paging every
+     * other simulated listing leaves out, so the answer is never truncated and
+     * carries no `NextMarker`.
+     */
+    async handle(command, options) {
+        await this.access.background.sequence();
+        const distribution = this.access.authorizedDistribution(SimCfListInvalidations.action, command.input.DistributionId, options?.caller);
+        const invalidations = distribution.invalidations.newestFirst();
+        return {
+            InvalidationList: {
+                Marker: command.input.Marker ?? "",
+                MaxItems: command.input.MaxItems ?? defaultMaxItems,
+                IsTruncated: false,
+                Quantity: invalidations.length,
+                Items: invalidations.map((invalidation) => simCfInvalidationSummary(invalidation)),
+            },
+            $metadata: {},
+        };
+    }
+}

package/dist/service/cloudfront/command/update-distribution/update-distribution.handler.d.ts

@@ -9,7 +9,9 @@ import type { SimCfEdgeFunctions } from "../../edge/sim-cf-edge-functions.js";
 import type { SimCfCustomOriginDispatcher } from "../../origin/custom/sim-cf-custom-origin-dispatcher.js";
 import type { SimCloudFrontS3OriginResolver } from "../../origin/s3/sim-cloudfront-s3-origin.js";
 import type { SimCloudFrontOriginAccessControlRegistry } from "../../origin-access-control/sim-cf-origin-access-control-registry.js";
+import type { SimCloudFrontOriginRequestPolicyRegistry } from "../../origin-request-policy/sim-cf-origin-request-policy-registry.js";
 import type { SimCloudFrontResponseHeadersPolicyRegistry } from "../../response-headers-policy/sim-cf-response-headers-policy-registry.js";
+import type { SimCloudFrontCachePolicyRegistry } from "../../cache-policy/sim-cf-cache-policy-registry.js";
 import type { SimCfWebAclResolver } from "../../web-acl/sim-cf-web-acl.js";
 import type { SimCloudFrontRegistry } from "../../registry/sim-cloud-front-registry.js";
 import type { SimUpdateDistributionCommand, SimUpdateDistributionCommandOutput } from "./update-distribution.command.js";
@@ -21,6 +23,8 @@ interface UpdateDistributionCommandHandlerProperties {
     readonly customOriginDispatcher?: SimCfCustomOriginDispatcher | undefined;
     readonly originAccessControls: SimCloudFrontOriginAccessControlRegistry;
     readonly responseHeadersPolicies: SimCloudFrontResponseHeadersPolicyRegistry;
+    readonly cachePolicies: SimCloudFrontCachePolicyRegistry;
+    readonly originRequestPolicies: SimCloudFrontOriginRequestPolicyRegistry;
     readonly webAclResolver?: SimCfWebAclResolver | undefined;
     readonly iam?: SimIamInterServiceAuthZ;
     readonly acmRegistry?: SimAcmRegistry | undefined;

package/dist/service/cloudfront/controller/content/sim-cf-content-stage.d.ts

@@ -0,0 +1,51 @@
+import type { SimCloudFrontBehavior } from "../../behaviour/sim-cloud-front-behavior.js";
+import type { SimCloudFrontDistribution } from "../../distribution/sim-cloudfront-distribution.js";
+import type { SimCloudFront } from "../../sim-cloudfront.js";
+import type { SimCfCustomErrorResponder } from "../error/sim-cf-custom-error-responder.js";
+import type { SimCfOriginStage, SimCfOriginStageResult } from "../origin/sim-cf-origin-stage.js";
+/**
+ * One request, and everything the content stage needs to answer it.
+ */
+export interface SimCfContentRequest {
+    readonly request: Request;
+    readonly cloudFront: SimCloudFront;
+    readonly distribution: SimCloudFrontDistribution;
+    readonly behaviour: SimCloudFrontBehavior;
+    /**
+     * The edge the request arrived at, whose cache answers it.
+     */
+    readonly edgeId: string;
+}
+/**
+ * What the content stage produced, and which of the two produced it.
+ */
+export interface SimCfContentStageResult extends SimCfOriginStageResult {
+    /**
+     * Whether the Distribution's cache answered, which the pipeline reports to
+     * the viewer in `X-Cache`.
+     */
+    readonly cacheHit: boolean;
+}
+/**
+ * Answers a request from the Distribution's cache, or from the Origin.
+ *
+ * This is CloudFront's cache lookup and everything behind it. A key the cache
+ * holds unexpired is answered with the Origin left unread. A miss goes to the
+ * Origin, has an error replaced with the Distribution's custom error page, and
+ * is stored under the key it missed on for as long as the Origin's headers and
+ * the cache policy between them allow.
+ *
+ * An error is stored for a TTL of its own. The `ErrorCachingMinTTL` of the
+ * custom error response matching the status decides it, whether the Origin
+ * answered with the error or an origin-response function made one of an
+ * Origin's answer.
+ */
+export declare class SimCfContentStage {
+    private readonly originStage;
+    private readonly customErrorResponder;
+    constructor(originStage: SimCfOriginStage, customErrorResponder: SimCfCustomErrorResponder);
+    /**
+     * Answer one request, reading the Origin only where the cache cannot.
+     */
+    serve(content: SimCfContentRequest): Promise<SimCfContentStageResult>;
+}

package/dist/service/cloudfront/controller/content/sim-cf-content-stage.js

@@ -0,0 +1,65 @@
+import { simCfCacheableRequest } from "../../cache/sim-cf-cacheable-request.js";
+import { simCfCacheTtlSec } from "../../cache/sim-cf-cache-ttl.js";
+import { simCfErrorCacheTtlSec } from "../../cache/sim-cf-error-cache-ttl.js";
+/**
+ * Answers a request from the Distribution's cache, or from the Origin.
+ *
+ * This is CloudFront's cache lookup and everything behind it. A key the cache
+ * holds unexpired is answered with the Origin left unread. A miss goes to the
+ * Origin, has an error replaced with the Distribution's custom error page, and
+ * is stored under the key it missed on for as long as the Origin's headers and
+ * the cache policy between them allow.
+ *
+ * An error is stored for a TTL of its own. The `ErrorCachingMinTTL` of the
+ * custom error response matching the status decides it, whether the Origin
+ * answered with the error or an origin-response function made one of an
+ * Origin's answer.
+ */
+export class SimCfContentStage {
+    originStage;
+    customErrorResponder;
+    constructor(originStage, customErrorResponder) {
+        this.originStage = originStage;
+        this.customErrorResponder = customErrorResponder;
+    }
+    /**
+     * Answer one request, reading the Origin only where the cache cannot.
+     */
+    async serve(content) {
+        const { request, distribution, behaviour } = content;
+        const cacheable = simCfCacheableRequest(content);
+        const cached = cacheable === undefined
+            ? undefined
+            : distribution.cache.read(cacheable.key);
+        // A hit is answered as the Origin answered it when it was stored, so the
+        // status the pipeline reads is the cached one and a viewer-response
+        // function runs on a hit as it ran on the miss that filled the cache.
+        if (cached !== undefined) {
+            return { response: cached, originStatus: cached.status, cacheHit: true };
+        }
+        const originResult = await this.originStage.fetch(request, distribution, behaviour);
+        const response = await this.customErrorResponder.apply(request, distribution, originResult.response);
+        if (cacheable === undefined) {
+            return {
+                response,
+                originStatus: originResult.originStatus,
+                cacheHit: false,
+            };
+        }
+        const errorTtlSec = simCfErrorCacheTtlSec({
+            originStatus: originResult.originStatus,
+            response,
+            customErrorResponses: distribution.customErrorResponses,
+        });
+        return {
+            response: await distribution.cache.store(cacheable.key, response, errorTtlSec ??
+                simCfCacheTtlSec({
+                    response,
+                    policy: cacheable.policy,
+                    now: distribution.clock.now(),
+                })),
+            originStatus: originResult.originStatus,
+            cacheHit: false,
+        };
+    }
+}

package/dist/service/cloudfront/controller/dependency/sim-cf-controller-dependency.d.ts

@@ -6,7 +6,7 @@ import { SimCffApplicator } from "../cff/sim-cff-applicator.js";
 import { SimLambdaEdgeApplicator } from "../edge/sim-lambda-edge-applicator.js";
 import { SimLambdaEdgeOriginApplicator } from "../edge/sim-lambda-edge-origin-applicator.js";
 import { SimCloudFrontOriginFetcher } from "../origin/sim-cloudfront-origin-fetcher.js";
-import { SimCfOriginStage } from "../origin/sim-cf-origin-stage.js";
+import { SimCfContentStage } from "../content/sim-cf-content-stage.js";
 import { SimCfCustomErrorResponder } from "../error/sim-cf-custom-error-responder.js";
 import { SimCfResponseHeadersApplicator } from "../response-headers/sim-cf-response-headers-applicator.js";
 import { SimCfWebAclGuard } from "../web-acl/sim-cf-web-acl-guard.js";
@@ -29,8 +29,7 @@ export interface SimCloudFrontControllerDependencies {
     readonly behaviourResolver: SimCloudFrontBehaviorResolver;
     readonly cffApplicator: SimCffApplicator;
     readonly edgeApplicator: SimLambdaEdgeApplicator;
-    readonly originStage: SimCfOriginStage;
-    readonly customErrorResponder: SimCfCustomErrorResponder;
+    readonly contentStage: SimCfContentStage;
     readonly responseHeadersApplicator: SimCfResponseHeadersApplicator;
 }
 /**

package/dist/service/cloudfront/controller/dependency/sim-cf-controller-dependency.js

@@ -7,6 +7,7 @@ import { SimLambdaEdgeOriginApplicator } from "../edge/sim-lambda-edge-origin-ap
 import { SimAwsCfEdgeFunctions } from "../../edge/sim-aws-cf-edge-functions.js";
 import { SimCloudFrontOriginFetcher } from "../origin/sim-cloudfront-origin-fetcher.js";
 import { SimCfOriginStage } from "../origin/sim-cf-origin-stage.js";
+import { SimCfContentStage } from "../content/sim-cf-content-stage.js";
 import { SimCfCustomErrorResponder } from "../error/sim-cf-custom-error-responder.js";
 import { SimCfResponseHeadersApplicator } from "../response-headers/sim-cf-response-headers-applicator.js";
 import { SimCfWebAclGuard } from "../web-acl/sim-cf-web-acl-guard.js";
@@ -40,10 +41,9 @@ export class SimCloudFrontControllerDependenciesFactory {
             cffApplicator: properties.cffApplicator ?? new SimCffApplicator(),
             edgeApplicator: properties.edgeApplicator ??
                 new SimLambdaEdgeApplicator({ edgeFunctions }),
-            originStage: new SimCfOriginStage(originFetcher, properties.edgeOriginApplicator ??
-                new SimLambdaEdgeOriginApplicator({ edgeFunctions })),
-            customErrorResponder: properties.customErrorResponder ??
-                new SimCfCustomErrorResponder({ behaviourResolver, originFetcher }),
+            contentStage: new SimCfContentStage(new SimCfOriginStage(originFetcher, properties.edgeOriginApplicator ??
+                new SimLambdaEdgeOriginApplicator({ edgeFunctions })), properties.customErrorResponder ??
+                new SimCfCustomErrorResponder({ behaviourResolver, originFetcher })),
             responseHeadersApplicator: properties.responseHeadersApplicator ??
                 new SimCfResponseHeadersApplicator(),
         };

package/dist/service/cloudfront/controller/error/sim-cf-custom-error-responder.d.ts

@@ -12,6 +12,10 @@ interface SimCfCustomErrorResponderProperties {
  * matching the response page path decides which Origin it comes from. That is
  * what lets a Distribution keep its error pages somewhere other than the
  * content that failed, as CloudFront does.
+ *
+ * A rule carrying `ErrorCachingMinTTL` alone has no page. The Origin's error
+ * reaches the viewer, and the rule says how long the Distribution holds it
+ * for.
  */
 export declare class SimCfCustomErrorResponder {
     private readonly behaviourResolver;