@kensio/yulin 1.21.9 → 1.21.11

package/dist/serve/payload-2/sim-payload-2-endpoint.d.ts

@@ -29,6 +29,15 @@ export interface SimPayload2Endpoint {
     readonly pathParameters?: Record<string, string> | undefined;
     /** The stage's variables, if it has any. */
     readonly stageVariables?: Record<string, string> | undefined;
+    /**
+     * The id the endpoint assigned to this request, where the endpoint assigns
+     * one before building the event.
+     *
+     * An HTTP API settles it up front so that the request's access log line, its
+     * authorizer event and its integration event all name the same request.
+     * Absent for an endpoint that leaves the event builder to issue one.
+     */
+    readonly requestId?: string | undefined;
 }
 /**
  * The path an event reports for one request to an endpoint.

package/dist/serve/payload-2/sim-payload-2-request-context.js

@@ -31,7 +31,7 @@ export class SimPayload2RequestContextBuilder {
                 sourceIp: simAwsProxiedSourceIp,
                 userAgent: request.headers.get("user-agent") ?? "",
             },
-            requestId: randomUUID(),
+            requestId: endpoint.requestId ?? randomUUID(),
             routeKey: endpoint.routeKey,
             stage: endpoint.stage,
             time: simProxyEventTime(at),

package/dist/service/apigatewayv2/api/sim-http-api-lambda-proxy.factory.d.ts

@@ -1,6 +1,7 @@
 import { AsyncMappedFactory } from "@kensio/part-factory";
 import type { SimPayload2Event } from "../../../serve/payload-2/sim-payload-2-event.type.js";
 import type { SimAws } from "../../aws/sim-aws.js";
+import type { SimHttpApiAccessLogSettingsInput } from "./stage/access-log/sim-http-api-access-log-settings.type.js";
 import type { SimHttpApiRouteSettings, SimHttpApiRouteSettingsMap } from "./stage/settings/sim-http-api-route-settings.type.js";
 import type { SimHttpApi } from "./sim-http-api.js";
 import { type SimHttpApiProxyAuthorizer } from "./sim-http-api-proxy-authorization.js";
@@ -47,6 +48,11 @@ export interface SimHttpApiLambdaProxyInput {
     readonly defaultRouteSettings: SimHttpApiRouteSettings | undefined;
     /** The throttles those stages apply to the route keys they name. */
     readonly routeSettings: SimHttpApiRouteSettingsMap | undefined;
+    /**
+     * Where those stages write an access log line per request, or undefined for
+     * stages that log nothing.
+     */
+    readonly accessLogSettings: SimHttpApiAccessLogSettingsInput | undefined;
     /**
      * Whether the function grants the API permission to invoke it, which it
      * needs before any route serves anything.

package/dist/service/apigatewayv2/api/sim-http-api-lambda-proxy.factory.js

@@ -42,6 +42,7 @@ export const simHttpApiLambdaProxyFactory = new AsyncMappedFactory(() => ({
     stageVariables: {},
     defaultRouteSettings: undefined,
     routeSettings: undefined,
+    accessLogSettings: undefined,
     invokePermission: true,
 }), async (input, simAws) => {
     const simLambda = simAws.account(input.functionAccountId).lambda();
@@ -107,6 +108,7 @@ export const simHttpApiLambdaProxyFactory = new AsyncMappedFactory(() => ({
             StageVariables: input.stageVariables,
             DefaultRouteSettings: input.defaultRouteSettings,
             RouteSettings: input.routeSettings,
+            AccessLogSettings: input.accessLogSettings,
         },
     })));
     // An id CreateApi allocated is an API the store holds, so this is only

package/dist/service/apigatewayv2/api/stage/access-log/sim-http-api-access-log-format.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Substitute a stage's access log format into the line one request writes.
+ *
+ * Everything outside a `$context` reference is copied through, which is what
+ * carries the punctuation of a JSON format string into the log group. A
+ * reference this simulation has no value for renders as a dash.
+ */
+export declare function simHttpApiAccessLogLine(format: string, variables: ReadonlyMap<string, string>): string;

package/dist/service/apigatewayv2/api/stage/access-log/sim-http-api-access-log-format.js

@@ -0,0 +1,36 @@
+/**
+ * What a variable with no value renders as.
+ *
+ * Real API Gateway writes a single dash where a `$context` variable has
+ * nothing behind it, such as `$context.integrationStatus` on a request no
+ * integration ran for. AWS publishes the variables and leaves this rendering
+ * undocumented, so it is what the service was observed to do.
+ */
+const noValue = "-";
+/**
+ * A `$context` reference, which is the name after the prefix and may carry
+ * dots of its own, as `$context.identity.sourceIp` does.
+ *
+ * The name is matched as one run of word characters and dots. Written as a
+ * repeated group it would nest two quantifiers, which is a shape a scanner
+ * flags however the input is bounded, and this matches the same names.
+ */
+const contextReference = /\$context\.[A-Za-z0-9_.]+/g;
+/**
+ * Substitute a stage's access log format into the line one request writes.
+ *
+ * Everything outside a `$context` reference is copied through, which is what
+ * carries the punctuation of a JSON format string into the log group. A
+ * reference this simulation has no value for renders as a dash.
+ */
+export function simHttpApiAccessLogLine(format, variables) {
+    return format.replaceAll(contextReference, (reference) => {
+        // A trailing dot belongs to the text around the reference rather than to
+        // the name, as in a format ending one variable with a full stop. It is put
+        // back after the value, so the punctuation survives the substitution.
+        const written = reference.slice("$context.".length);
+        const name = written.replace(/\.+$/, "");
+        const punctuation = written.slice(name.length);
+        return (variables.get(name) ?? noValue) + punctuation;
+    });
+}

package/dist/service/apigatewayv2/api/stage/access-log/sim-http-api-access-log-request.d.ts

@@ -0,0 +1,53 @@
+import type { SimPayload2JwtAuthorizer, SimPayload2LambdaAuthorizer } from "../../../../../serve/payload-2/sim-payload-2-event.type.js";
+/**
+ * Everything one served request contributes to its access log line.
+ *
+ * A request refused before an integration ran fills in what it knows and
+ * leaves the rest out. That is the case the access log exists for: a Lambda
+ * authorizer denial, an absent identity source and a throttled request each
+ * produce a line describing a request no handler ever saw.
+ */
+export interface SimHttpApiAccessLogRequest {
+    readonly requestId: string;
+    /** The simulated instant the request arrived. */
+    readonly at: Date;
+    readonly accountId: string;
+    readonly apiId: string;
+    readonly domainName: string;
+    readonly domainPrefix: string;
+    readonly stage: string;
+    readonly routeKey: string;
+    readonly method: string;
+    readonly path: string;
+    readonly protocol: string;
+    readonly sourceIp: string;
+    readonly userAgent: string;
+    readonly status: number;
+    readonly responseLength: number;
+    /** Milliseconds of simulated time the whole request took. */
+    readonly responseLatency: number;
+    /**
+     * The status the integrated function's own code returned, which is what
+     * `$context.integration.status` reports. Absent where no integration ran.
+     */
+    readonly integrationStatus?: number | undefined;
+    /**
+     * The status Lambda answered the invocation with, which is what
+     * `$context.integrationStatus` reports for a Lambda proxy integration. It is
+     * 200 for an invocation that reached the handler, whatever the handler then
+     * returned.
+     */
+    readonly lambdaInvokeStatus?: number | undefined;
+    readonly integrationLatency?: number | undefined;
+    readonly integrationErrorMessage?: string | undefined;
+    /** The message an authorizer refusal leaves behind, where it left one. */
+    readonly authorizerError?: string | undefined;
+    /** The message the endpoint answered with, such as `Forbidden`. */
+    readonly errorMessage?: string | undefined;
+    /** The base path an API mapping matched, for a custom domain request. */
+    readonly basePathMatched?: string | undefined;
+    /** What a `JWT` route's authorizer accepted, where one did. */
+    readonly jwt?: SimPayload2JwtAuthorizer | undefined;
+    /** What a `CUSTOM` route's Lambda authorizer passed on, where one did. */
+    readonly lambda?: SimPayload2LambdaAuthorizer | null | undefined;
+}

package/dist/service/apigatewayv2/api/stage/access-log/sim-http-api-access-log-request.js

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

package/dist/service/apigatewayv2/api/stage/access-log/sim-http-api-access-log-settings.d.ts

@@ -0,0 +1,26 @@
+import type { SimHttpApiAccessLogSettingsView } from "./sim-http-api-access-log-settings.type.js";
+/**
+ * Where one stage writes its access log, and the line it writes there.
+ *
+ * The destination is held as the ARN the stage was created with and as the
+ * account, region and group that ARN resolves to. A log group in another
+ * Account is written to in that Account, the way an integration invokes the
+ * function its own URI names.
+ */
+export declare class SimHttpApiAccessLogSettings {
+    readonly destinationArn: string;
+    readonly format: string;
+    readonly accountId: string;
+    readonly regionName: string;
+    readonly logGroupName: string;
+    private constructor();
+    /**
+     * Read settings from a destination ARN and a format, or answer with nothing
+     * where the ARN names no log group.
+     */
+    static from(destinationArn: string, format: string): SimHttpApiAccessLogSettings | undefined;
+    /**
+     * What CreateStage and GetStages report of these settings.
+     */
+    view(): SimHttpApiAccessLogSettingsView;
+}

package/dist/service/apigatewayv2/api/stage/access-log/sim-http-api-access-log-settings.js

@@ -0,0 +1,44 @@
+import { simLogsParsedLogGroupArn } from "../../../../logs/group/sim-logs-arn.js";
+/**
+ * Where one stage writes its access log, and the line it writes there.
+ *
+ * The destination is held as the ARN the stage was created with and as the
+ * account, region and group that ARN resolves to. A log group in another
+ * Account is written to in that Account, the way an integration invokes the
+ * function its own URI names.
+ */
+export class SimHttpApiAccessLogSettings {
+    destinationArn;
+    format;
+    accountId;
+    regionName;
+    logGroupName;
+    constructor(properties) {
+        this.destinationArn = properties.destinationArn;
+        this.format = properties.format;
+        this.accountId = properties.accountId;
+        this.regionName = properties.regionName;
+        this.logGroupName = properties.logGroupName;
+    }
+    /**
+     * Read settings from a destination ARN and a format, or answer with nothing
+     * where the ARN names no log group.
+     */
+    static from(destinationArn, format) {
+        const parsed = simLogsParsedLogGroupArn(destinationArn);
+        if (parsed === undefined) {
+            return undefined;
+        }
+        return new SimHttpApiAccessLogSettings({
+            destinationArn,
+            format,
+            ...parsed,
+        });
+    }
+    /**
+     * What CreateStage and GetStages report of these settings.
+     */
+    view() {
+        return { DestinationArn: this.destinationArn, Format: this.format };
+    }
+}

package/dist/service/apigatewayv2/api/stage/access-log/sim-http-api-access-log-settings.type.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The `AccessLogSettings` a stage is created with.
+ *
+ * `DestinationArn` names a CloudWatch Logs log group. HTTP APIs accept no
+ * other destination, and a Kinesis Data Firehose delivery stream is a REST API
+ * option that this shape leaves out.
+ *
+ * `Format` is the line written per request, with `$context` variables
+ * substituted from the request that produced it.
+ */
+export interface SimHttpApiAccessLogSettingsInput {
+    readonly DestinationArn?: string | undefined;
+    readonly Format?: string | undefined;
+}
+/**
+ * What a stage reports of the access log settings it was created with.
+ */
+export interface SimHttpApiAccessLogSettingsView {
+    DestinationArn: string;
+    Format: string;
+}

package/dist/service/apigatewayv2/api/stage/access-log/sim-http-api-access-log-settings.type.js

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

package/dist/service/apigatewayv2/api/stage/access-log/sim-http-api-access-log-stream-name.d.ts

@@ -0,0 +1,13 @@
+import type { SimClock } from "../../../../../util/clock/sim-clock.js";
+/**
+ * The stream a stage's access log events are written to.
+ *
+ * Real API Gateway rolls access log streams over time and appends an
+ * identifier this simulation has no counterpart for. The hour is what decides
+ * the stream here, dated from the simulation's clock, so a test that froze
+ * time gets one stream and a predictable name for it. The shape is chosen for
+ * the simulation rather than copied from an observed account, and a test
+ * reading its lines back should filter the log group rather than name the
+ * stream.
+ */
+export declare function simHttpApiAccessLogStreamName(clock: SimClock): string;

package/dist/service/apigatewayv2/api/stage/access-log/sim-http-api-access-log-stream-name.js

@@ -0,0 +1,23 @@
+function twoDigits(value) {
+    return String(value).padStart(2, "0");
+}
+/**
+ * The stream a stage's access log events are written to.
+ *
+ * Real API Gateway rolls access log streams over time and appends an
+ * identifier this simulation has no counterpart for. The hour is what decides
+ * the stream here, dated from the simulation's clock, so a test that froze
+ * time gets one stream and a predictable name for it. The shape is chosen for
+ * the simulation rather than copied from an observed account, and a test
+ * reading its lines back should filter the log group rather than name the
+ * stream.
+ */
+export function simHttpApiAccessLogStreamName(clock) {
+    const at = clock.now();
+    return [
+        String(at.getUTCFullYear()),
+        twoDigits(at.getUTCMonth() + 1),
+        twoDigits(at.getUTCDate()),
+        twoDigits(at.getUTCHours()),
+    ].join("-");
+}

package/dist/service/apigatewayv2/api/stage/access-log/sim-http-api-access-log-variables.d.ts

@@ -0,0 +1,17 @@
+import type { SimHttpApiAccessLogRequest } from "./sim-http-api-access-log-request.js";
+/**
+ * The `$context` variables one request answers, keyed by the name that follows
+ * `$context.`.
+ *
+ * A variable this simulation has no value for is left out of the map. The
+ * substitution writes `-` for it, which is what real API Gateway writes for a
+ * variable with no value. That rendering is what the service was observed to
+ * do rather than something AWS publishes.
+ *
+ * `$context.extendedRequestId` and `$context.integration.latency` are
+ * documented as equivalents of the flat names, and carry the same values here.
+ * `$context.integrationStatus` is the status Lambda answered the invocation
+ * with, and `$context.integration.status` the one the handler's own code
+ * returned, which is the distinction AWS draws between the two.
+ */
+export declare function simHttpApiAccessLogVariables(request: SimHttpApiAccessLogRequest): ReadonlyMap<string, string>;

package/dist/service/apigatewayv2/api/stage/access-log/sim-http-api-access-log-variables.js

@@ -0,0 +1,86 @@
+import { simProxyEventTime } from "../../../../../serve/proxy/sim-proxy-event-time.js";
+function numberOrUndefined(value) {
+    return value === undefined ? undefined : String(value);
+}
+/**
+ * The `$context` variables one request answers, keyed by the name that follows
+ * `$context.`.
+ *
+ * A variable this simulation has no value for is left out of the map. The
+ * substitution writes `-` for it, which is what real API Gateway writes for a
+ * variable with no value. That rendering is what the service was observed to
+ * do rather than something AWS publishes.
+ *
+ * `$context.extendedRequestId` and `$context.integration.latency` are
+ * documented as equivalents of the flat names, and carry the same values here.
+ * `$context.integrationStatus` is the status Lambda answered the invocation
+ * with, and `$context.integration.status` the one the handler's own code
+ * returned, which is the distinction AWS draws between the two.
+ */
+export function simHttpApiAccessLogVariables(request) {
+    const variables = new Map([
+        ["accountId", request.accountId],
+        ["apiId", request.apiId],
+        ["domainName", request.domainName],
+        ["domainPrefix", request.domainPrefix],
+        ["stage", request.stage],
+        ["routeKey", request.routeKey],
+        ["httpMethod", request.method],
+        ["path", request.path],
+        ["protocol", request.protocol],
+        ["requestId", request.requestId],
+        ["extendedRequestId", request.requestId],
+        ["requestTime", simProxyEventTime(request.at)],
+        ["requestTimeEpoch", String(request.at.getTime())],
+        ["status", String(request.status)],
+        ["responseLength", String(request.responseLength)],
+        ["responseLatency", String(request.responseLatency)],
+        ["identity.sourceIp", request.sourceIp],
+        ["identity.userAgent", request.userAgent],
+        ["integrationStatus", numberOrUndefined(request.lambdaInvokeStatus)],
+        [
+            "integration.integrationStatus",
+            numberOrUndefined(request.lambdaInvokeStatus),
+        ],
+        ["integrationLatency", numberOrUndefined(request.integrationLatency)],
+        ["integration.latency", numberOrUndefined(request.integrationLatency)],
+        ["integration.status", numberOrUndefined(request.integrationStatus)],
+        ["integrationErrorMessage", request.integrationErrorMessage],
+        ["integration.error", request.integrationErrorMessage],
+        ["authorizer.error", request.authorizerError],
+        ["error.message", request.errorMessage],
+        ["customDomain.basePathMatched", request.basePathMatched],
+    ]);
+    addQuotedMessage(variables, request);
+    addAuthorizerProperties(variables, request);
+    return new Map([...variables].flatMap(([name, value]) => value === undefined ? [] : [[name, value]]));
+}
+/**
+ * `$context.error.messageString` is the quoted form of the message, which is
+ * what a JSON format string uses to keep its own quoting intact.
+ */
+function addQuotedMessage(variables, request) {
+    if (request.errorMessage !== undefined) {
+        variables.set("error.messageString", `"${request.errorMessage}"`);
+    }
+}
+/**
+ * The claims a `JWT` route's authorizer accepted and the context map a
+ * `CUSTOM` route's authorizer returned.
+ *
+ * Both are reached by naming the property. `$context.authorizer.claims` and
+ * `$context.authorizer` name no property, and AWS documents the first of those
+ * as returning null, so neither is given a value here.
+ */
+function addAuthorizerProperties(variables, request) {
+    const claims = Object.entries(request.jwt?.claims ?? {});
+    const authorizerContext = Object.entries(request.lambda ?? {});
+    for (const [claim, value] of claims) {
+        variables.set(`authorizer.claims.${claim}`, value);
+    }
+    for (const [key, value] of authorizerContext) {
+        if (value !== null && typeof value !== "object") {
+            variables.set(`authorizer.${key}`, String(value));
+        }
+    }
+}

package/dist/service/apigatewayv2/api/stage/sim-http-api-stage.d.ts

@@ -1,3 +1,5 @@
+import type { SimHttpApiAccessLogSettings } from "./access-log/sim-http-api-access-log-settings.js";
+import type { SimHttpApiAccessLogSettingsView } from "./access-log/sim-http-api-access-log-settings.type.js";
 import type { SimHttpApiRouteSettingsView } from "./settings/sim-http-api-route-settings.type.js";
 import type { SimHttpApiStageRouteSettings } from "./settings/sim-http-api-stage-route-settings.js";
 /**
@@ -12,6 +14,7 @@ interface SimHttpApiStageProperties {
     readonly description?: string | undefined;
     readonly createdDate: Date;
     readonly routeSettings?: SimHttpApiStageRouteSettings | undefined;
+    readonly accessLogSettings?: SimHttpApiAccessLogSettings | undefined;
 }
 /**
  * Minimal structural stage view, as the Create and Get commands return.
@@ -22,6 +25,7 @@ export interface SimHttpApiStageView extends SimHttpApiRouteSettingsView {
     CreatedDate: Date;
     StageVariables?: Record<string, string>;
     Description?: string;
+    AccessLogSettings?: SimHttpApiAccessLogSettingsView;
 }
 /**
  * A simulated HTTP API stage.
@@ -41,6 +45,11 @@ export declare class SimHttpApiStage {
      * that was given no route settings and so throttles nothing.
      */
     readonly routeSettings?: SimHttpApiStageRouteSettings | undefined;
+    /**
+     * Where this stage writes an access log line per request, or undefined for a
+     * stage that was given no access log settings and so logs nothing.
+     */
+    readonly accessLogSettings?: SimHttpApiAccessLogSettings | undefined;
     constructor(properties: SimHttpApiStageProperties);
     /**
      * Whether this stage's throttle serves one more request to a route key now.

package/dist/service/apigatewayv2/api/stage/sim-http-api-stage.js

@@ -21,6 +21,11 @@ export class SimHttpApiStage {
      * that was given no route settings and so throttles nothing.
      */
     routeSettings;
+    /**
+     * Where this stage writes an access log line per request, or undefined for a
+     * stage that was given no access log settings and so logs nothing.
+     */
+    accessLogSettings;
     constructor(properties) {
         this.stageName = properties.stageName;
         this.autoDeploy = properties.autoDeploy;
@@ -28,6 +33,7 @@ export class SimHttpApiStage {
         this.description = properties.description;
         this.createdDate = properties.createdDate;
         this.routeSettings = properties.routeSettings;
+        this.accessLogSettings = properties.accessLogSettings;
     }
     /**
      * Whether this stage's throttle serves one more request to a route key now.
@@ -57,6 +63,9 @@ export class SimHttpApiStage {
         if (this.description !== undefined) {
             view.Description = this.description;
         }
+        if (this.accessLogSettings !== undefined) {
+            view.AccessLogSettings = this.accessLogSettings.view();
+        }
         return view;
     }
 }

package/dist/service/apigatewayv2/cfn/stage/sim-cfn-http-api-access-log-settings-properties.d.ts

@@ -0,0 +1,24 @@
+import type { SimCfnResource } from "../../../cloudformation/resource/sim-cfn-resource.js";
+import type { SimCfnTemplateValue } from "../../../cloudformation/template/value/sim-cfn-template-value.js";
+import type { SimHttpApiAccessLogSettingsInput } from "../../api/stage/access-log/sim-http-api-access-log-settings.type.js";
+import type { SimCfnApiGatewayV2PropertyParser } from "../sim-cfn-api-gateway-v2-property-parser.js";
+interface SimCfnHttpApiAccessLogSettingsPropertiesProperties {
+    readonly resource: SimCfnResource;
+    readonly propertyParser: SimCfnApiGatewayV2PropertyParser;
+}
+/**
+ * Reads the `AccessLogSettings` of an AWS::ApiGatewayV2::Stage.
+ *
+ * `DestinationArn` reaches the template as a `Fn::GetAtt` on the log group's
+ * `Arn`, which CDK emits and which resolves to the form ending in `:*`. The
+ * form without it, as `DescribeLogGroups` reports, names the same group.
+ */
+export declare class SimCfnHttpApiAccessLogSettingsProperties {
+    #private;
+    constructor(properties: SimCfnHttpApiAccessLogSettingsPropertiesProperties);
+    /**
+     * Read the `AccessLogSettings` a stage was declared with.
+     */
+    settings(value: SimCfnTemplateValue | undefined, label: string): SimHttpApiAccessLogSettingsInput | undefined;
+}
+export {};

package/dist/service/apigatewayv2/cfn/stage/sim-cfn-http-api-access-log-settings-properties.js

@@ -0,0 +1,30 @@
+/**
+ * Reads the `AccessLogSettings` of an AWS::ApiGatewayV2::Stage.
+ *
+ * `DestinationArn` reaches the template as a `Fn::GetAtt` on the log group's
+ * `Arn`, which CDK emits and which resolves to the form ending in `:*`. The
+ * form without it, as `DescribeLogGroups` reports, names the same group.
+ */
+export class SimCfnHttpApiAccessLogSettingsProperties {
+    #resource;
+    #propertyParser;
+    constructor(properties) {
+        this.#resource = properties.resource;
+        this.#propertyParser = properties.propertyParser;
+    }
+    /**
+     * Read the `AccessLogSettings` a stage was declared with.
+     */
+    settings(value, label) {
+        const record = this.#propertyParser.optionalRecord(this.#resource, value, label);
+        if (record === undefined) {
+            return undefined;
+        }
+        const destinationArn = this.#propertyParser.optionalString(this.#resource, record["DestinationArn"], `${label}.DestinationArn`);
+        const format = this.#propertyParser.optionalString(this.#resource, record["Format"], `${label}.Format`);
+        return {
+            ...(destinationArn !== undefined && { DestinationArn: destinationArn }),
+            ...(format !== undefined && { Format: format }),
+        };
+    }
+}

package/dist/service/apigatewayv2/cfn/stage/sim-cfn-http-api-stage-properties.d.ts

@@ -14,6 +14,7 @@ export declare class SimCfnHttpApiStageProperties {
     private readonly properties;
     private readonly propertyParser;
     private readonly routeSettingsParser;
+    private readonly accessLogSettingsParser;
     constructor(properties: SimCfnHttpApiStagePropertiesProperties);
     /**
      * The API this stage belongs to, which a template reaches with a `Ref` on

package/dist/service/apigatewayv2/cfn/stage/sim-cfn-http-api-stage-properties.js

@@ -1,12 +1,11 @@
 import { SimCfnApiGatewayV2PropertyParser } from "../sim-cfn-api-gateway-v2-property-parser.js";
+import { SimCfnHttpApiAccessLogSettingsProperties } from "./sim-cfn-http-api-access-log-settings-properties.js";
 import { SimCfnHttpApiRouteSettingsProperties } from "./sim-cfn-http-api-route-settings-properties.js";
 /**
  * The AWS::ApiGatewayV2::Stage properties this simulation deploys.
  *
- * `DeploymentId`, `AccessLogSettings` and `Tags` are left out, so a template
- * carrying one is recorded and the stage is created without it. None of them
- * is modelled, and a stage that looked logged to the template and logged
- * nothing when serving is the failure worth recording.
+ * `DeploymentId` and `Tags` are left out, so a template carrying one is
+ * recorded and the stage is created without it. Neither is modelled.
  */
 const simulatedProperties = [
     "ApiId",
@@ -16,6 +15,7 @@ const simulatedProperties = [
     "Description",
     "DefaultRouteSettings",
     "RouteSettings",
+    "AccessLogSettings",
 ];
 /**
  * Reads AWS::ApiGatewayV2::Stage CloudFormation properties into the CreateStage
@@ -29,6 +29,7 @@ export class SimCfnHttpApiStageProperties {
         simulated: simulatedProperties,
     });
     routeSettingsParser;
+    accessLogSettingsParser;
     constructor(properties) {
         this.resource = properties.resource;
         this.properties = properties.properties;
@@ -36,6 +37,10 @@ export class SimCfnHttpApiStageProperties {
             resource: this.resource,
             propertyParser: this.propertyParser,
         });
+        this.accessLogSettingsParser = new SimCfnHttpApiAccessLogSettingsProperties({
+            resource: this.resource,
+            propertyParser: this.propertyParser,
+        });
         this.propertyParser.ignoreUnsimulated(this.resource, this.properties);
     }
     /**
@@ -68,6 +73,7 @@ export class SimCfnHttpApiStageProperties {
             Description: this.propertyParser.optionalString(this.resource, this.properties["Description"], "Description"),
             DefaultRouteSettings: this.routeSettingsParser.settings(this.properties["DefaultRouteSettings"], "DefaultRouteSettings"),
             RouteSettings: this.routeSettingsParser.settingsMap(this.properties["RouteSettings"], "RouteSettings"),
+            AccessLogSettings: this.accessLogSettingsParser.settings(this.properties["AccessLogSettings"], "AccessLogSettings"),
         };
     }
 }

package/dist/service/apigatewayv2/command/stage/sim-http-api-access-log-settings-input.d.ts

@@ -0,0 +1,15 @@
+import { SimHttpApiAccessLogSettings } from "../../api/stage/access-log/sim-http-api-access-log-settings.js";
+import type { SimApiGatewayV2UnsimulatedInput } from "../sim-api-gateway-v2-unsimulated-input.js";
+import type { SimCreateStageCommandInput } from "./stage.command.js";
+/**
+ * Reads the access log settings a CreateStage input asks for.
+ *
+ * Both members are required together. AWS types each as optional and a stage
+ * carrying one alone has either nowhere to write or nothing to write, so the
+ * pair is refused rather than half applied.
+ *
+ * `DestinationArn` has to name a CloudWatch Logs log group. HTTP APIs accept
+ * no other destination, and a Kinesis Data Firehose delivery stream, which a
+ * REST API stage may name, is refused here by the same check.
+ */
+export declare function simHttpApiAccessLogSettings(input: SimCreateStageCommandInput, unsimulated: SimApiGatewayV2UnsimulatedInput): SimHttpApiAccessLogSettings | undefined;

package/dist/service/apigatewayv2/command/stage/sim-http-api-access-log-settings-input.js

@@ -0,0 +1,33 @@
+import { SimHttpApiAccessLogSettings } from "../../api/stage/access-log/sim-http-api-access-log-settings.js";
+import { SimApiGatewayV2BadRequest } from "../../error/sim-api-gateway-v2.error.js";
+/** The `AccessLogSettings` members an HTTP API stage takes. */
+const acceptedAccessLogSettings = ["DestinationArn", "Format"];
+/**
+ * Reads the access log settings a CreateStage input asks for.
+ *
+ * Both members are required together. AWS types each as optional and a stage
+ * carrying one alone has either nowhere to write or nothing to write, so the
+ * pair is refused rather than half applied.
+ *
+ * `DestinationArn` has to name a CloudWatch Logs log group. HTTP APIs accept
+ * no other destination, and a Kinesis Data Firehose delivery stream, which a
+ * REST API stage may name, is refused here by the same check.
+ */
+export function simHttpApiAccessLogSettings(input, unsimulated) {
+    const settings = input.AccessLogSettings;
+    if (settings === undefined) {
+        return undefined;
+    }
+    unsimulated.refuseUnaccepted(settings, acceptedAccessLogSettings, "AccessLogSettings.");
+    const { DestinationArn: destinationArn, Format: format } = settings;
+    if (destinationArn === undefined || format === undefined) {
+        throw new SimApiGatewayV2BadRequest("CreateStage AccessLogSettings requires both DestinationArn and Format");
+    }
+    const accessLogSettings = SimHttpApiAccessLogSettings.from(destinationArn, format);
+    if (accessLogSettings === undefined) {
+        throw new SimApiGatewayV2BadRequest(`CreateStage AccessLogSettings DestinationArn '${destinationArn}' is ` +
+            `not a CloudWatch Logs log group ARN. An HTTP API stage writes its ` +
+            `access log to a log group and to nothing else.`);
+    }
+    return accessLogSettings;
+}