@kensio/yulin 1.21.3 → 1.21.5

package/dist/service/lambda/function/invoke/timer/sim-lambda-timer-handle.d.ts

@@ -0,0 +1,50 @@
+/**
+ * What a handler passes to `setTimeout` or `setInterval` to be run later.
+ */
+export type SimLambdaTimerCallback = (...arguments_: unknown[]) => void;
+/**
+ * Timer functions of the shape the Node.js runtime gives handler code.
+ */
+export interface SimLambdaTimers {
+    setTimeout(callback: SimLambdaTimerCallback, delay?: number, ...arguments_: unknown[]): SimLambdaTimerHandle | NodeJS.Timeout;
+    setInterval(callback: SimLambdaTimerCallback, delay?: number, ...arguments_: unknown[]): SimLambdaTimerHandle | NodeJS.Timeout;
+}
+/**
+ * Where a timer goes to be given up, which is the set it was made in.
+ */
+export interface SimLambdaTimerOwner {
+    clear(handle: SimLambdaTimerHandle): void;
+}
+/**
+ * The handle a handler gets back from `setTimeout` or `setInterval`.
+ *
+ * Real timer functions answer with an object rather than a number, and the
+ * only thing handler code usually does with it is hand it back to
+ * `clearTimeout`. It carries the set it belongs to, so clearing it reaches
+ * that set rather than whichever invocation happens to be running.
+ *
+ * Referencing is answered because a handler is free to ask. A simulated timer
+ * is unreferenced already: it waits on a clock a test moves, and holds nothing
+ * open whatever it is asked.
+ */
+export declare class SimLambdaTimerHandle {
+    #private;
+    constructor(owner: SimLambdaTimerOwner);
+    /**
+     * Give up this timer, as `clearTimeout` and `clearInterval` do.
+     */
+    cancel(): void;
+    /**
+     * Keep the simulation open for this timer, which it already is.
+     */
+    ref(): this;
+    /**
+     * Stop keeping the simulation open for this timer, which it never was.
+     */
+    unref(): this;
+    /**
+     * Whether this timer holds the process open, which a simulated one never
+     * does.
+     */
+    hasRef(): boolean;
+}

package/dist/service/lambda/function/invoke/timer/sim-lambda-timer-handle.js

@@ -0,0 +1,43 @@
+/**
+ * The handle a handler gets back from `setTimeout` or `setInterval`.
+ *
+ * Real timer functions answer with an object rather than a number, and the
+ * only thing handler code usually does with it is hand it back to
+ * `clearTimeout`. It carries the set it belongs to, so clearing it reaches
+ * that set rather than whichever invocation happens to be running.
+ *
+ * Referencing is answered because a handler is free to ask. A simulated timer
+ * is unreferenced already: it waits on a clock a test moves, and holds nothing
+ * open whatever it is asked.
+ */
+export class SimLambdaTimerHandle {
+    #owner;
+    constructor(owner) {
+        this.#owner = owner;
+    }
+    /**
+     * Give up this timer, as `clearTimeout` and `clearInterval` do.
+     */
+    cancel() {
+        this.#owner.clear(this);
+    }
+    /**
+     * Keep the simulation open for this timer, which it already is.
+     */
+    ref() {
+        return this;
+    }
+    /**
+     * Stop keeping the simulation open for this timer, which it never was.
+     */
+    unref() {
+        return this;
+    }
+    /**
+     * Whether this timer holds the process open, which a simulated one never
+     * does.
+     */
+    hasRef() {
+        return false;
+    }
+}

package/dist/service/lambda/function/logging/sim-lambda-function-logging.d.ts

@@ -1,6 +1,7 @@
 import type { SimClock } from "../../../../util/clock/sim-clock.js";
 import type { SimLogsServiceWriter } from "../../../logs/write/sim-logs-service-writer.js";
 import type { SimLambdaOutputSink } from "./sim-lambda-output-sink.js";
+import { SimLambdaOutput } from "./sim-lambda-output.js";
 import type { SimLambdaExecutableCode } from "../code/sim-lambda-executable-code.js";
 interface SimLambdaFunctionLoggingProperties {
     readonly functionName: string;
@@ -10,6 +11,12 @@ interface SimLambdaFunctionLoggingProperties {
      * instance, has no simulated CloudWatch Logs to record to.
      */
     readonly logs?: SimLogsServiceWriter | undefined;
+    /**
+     * Where this function's output goes besides its log group. Shared with every
+     * other function of the same simulated Lambda, and read as each line is
+     * written.
+     */
+    readonly output?: SimLambdaOutput | undefined;
 }
 /**
  * One function's side of writing its output to a log group.
@@ -28,6 +35,8 @@ interface SimLambdaFunctionLoggingProperties {
 export declare class SimLambdaFunctionLogging {
     #private;
     readonly logGroupName: string;
+    /** Where this function's output goes besides its log group. */
+    readonly output: SimLambdaOutput;
     constructor(properties: SimLambdaFunctionLoggingProperties);
     /**
      * The stream this function's execution environment writes to, opening it if
@@ -53,6 +62,14 @@ export declare class SimLambdaFunctionLogging {
      * console and standard streams tee into.
      */
     outputSink(): SimLambdaOutputSink | undefined;
+    /**
+     * Both halves of where a host-scope invocation's output goes, ready to
+     * bridge to the process globals it prints through.
+     */
+    outputScope(): {
+        readonly output: SimLambdaOutputSink | undefined;
+        readonly outputSettings: SimLambdaOutput;
+    };
     /**
      * Run an invocation, recording whatever it left unterminated once it is
      * over, and the error it ended in when it ended in one.

package/dist/service/lambda/function/logging/sim-lambda-function-logging.js

@@ -1,3 +1,4 @@
+import { SimLambdaOutput } from "./sim-lambda-output.js";
 import { simLambdaInvokeErrorLine } from "./sim-lambda-invoke-error-log.js";
 import { SimLambdaLogWriter } from "./sim-lambda-log-writer.js";
 import { simLambdaLogGroupName, simLambdaLogStreamName, } from "./sim-lambda-log-stream-name.js";
@@ -17,6 +18,8 @@ import { simLambdaLogGroupName, simLambdaLogStreamName, } from "./sim-lambda-log
  */
 export class SimLambdaFunctionLogging {
     logGroupName;
+    /** Where this function's output goes besides its log group. */
+    output;
     #logs;
     #clock;
     #writer;
@@ -25,6 +28,7 @@ export class SimLambdaFunctionLogging {
         this.logGroupName = simLambdaLogGroupName(properties.functionName);
         this.#logs = properties.logs;
         this.#clock = properties.clock;
+        this.output = properties.output ?? new SimLambdaOutput();
     }
     /**
      * The stream this function's execution environment writes to, opening it if
@@ -47,7 +51,7 @@ export class SimLambdaFunctionLogging {
     recordFrom(code) {
         const writer = this.#writer;
         if (writer !== undefined) {
-            code.recordOutputTo(writer);
+            code.recordOutputTo(writer, this.output);
         }
     }
     /**
@@ -61,6 +65,13 @@ export class SimLambdaFunctionLogging {
     outputSink() {
         return this.#writer;
     }
+    /**
+     * Both halves of where a host-scope invocation's output goes, ready to
+     * bridge to the process globals it prints through.
+     */
+    outputScope() {
+        return { output: this.#writer, outputSettings: this.output };
+    }
     /**
      * Run an invocation, recording whatever it left unterminated once it is
      * over, and the error it ended in when it ended in one.

package/dist/service/lambda/function/logging/sim-lambda-output.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Where a simulated Lambda's functions send what they print.
+ *
+ * Function output always reaches the function's log group. This settles the
+ * second destination, the host console the test run itself prints to. Real
+ * Lambda sends output to CloudWatch Logs and nowhere else, and Yulin forwards
+ * it to the host as well so that a failing test is as easy to read as one
+ * whose handler was never simulated.
+ *
+ * A handler that logs on every request makes that forwarding expensive. AWS
+ * Lambda Powertools writes an Embedded Metric Format document for every metric
+ * it counts, and a suite invoking a function a few hundred times buries its own
+ * output under them. `captureOnly` turns the forwarding off for every function
+ * of one simulated Lambda:
+ *
+ * ```typescript
+ * simAws.lambda().output().captureOnly();
+ * ```
+ *
+ * Nothing is lost by it. The log group holds every line either way, and
+ * `FilterLogEvents` reads them back.
+ *
+ * ## What it leaves alone
+ *
+ * A function with no simulated CloudWatch Logs behind it keeps printing to the
+ * host whatever this says. That is a function built on a standalone SimLambda,
+ * outside a SimAws instance, and it has no log group for its output to be read
+ * back out of. Silencing it would lose the output altogether.
+ *
+ * The setting is read as each line is written, so a test can turn forwarding
+ * off part way through a run and the functions that have already cold started
+ * follow it.
+ */
+export declare class SimLambdaOutput {
+    #private;
+    /**
+     * Record function output to its log group alone.
+     *
+     * Lines written from then on stay out of the host console. Everything
+     * written before it is already printed.
+     */
+    captureOnly(): void;
+    /**
+     * Forward function output to the host console as well as recording it, which
+     * is what a simulated Lambda does until told otherwise.
+     */
+    teeToHost(): void;
+    /**
+     * Whether a recorded line still reaches the host console.
+     *
+     * Read by the two paths that write one, the vm sandbox's standard streams
+     * and the process globals a host-scope handler prints through.
+     * @internal
+     */
+    reachesHost(): boolean;
+}

package/dist/service/lambda/function/logging/sim-lambda-output.js

@@ -0,0 +1,62 @@
+/**
+ * Where a simulated Lambda's functions send what they print.
+ *
+ * Function output always reaches the function's log group. This settles the
+ * second destination, the host console the test run itself prints to. Real
+ * Lambda sends output to CloudWatch Logs and nowhere else, and Yulin forwards
+ * it to the host as well so that a failing test is as easy to read as one
+ * whose handler was never simulated.
+ *
+ * A handler that logs on every request makes that forwarding expensive. AWS
+ * Lambda Powertools writes an Embedded Metric Format document for every metric
+ * it counts, and a suite invoking a function a few hundred times buries its own
+ * output under them. `captureOnly` turns the forwarding off for every function
+ * of one simulated Lambda:
+ *
+ * ```typescript
+ * simAws.lambda().output().captureOnly();
+ * ```
+ *
+ * Nothing is lost by it. The log group holds every line either way, and
+ * `FilterLogEvents` reads them back.
+ *
+ * ## What it leaves alone
+ *
+ * A function with no simulated CloudWatch Logs behind it keeps printing to the
+ * host whatever this says. That is a function built on a standalone SimLambda,
+ * outside a SimAws instance, and it has no log group for its output to be read
+ * back out of. Silencing it would lose the output altogether.
+ *
+ * The setting is read as each line is written, so a test can turn forwarding
+ * off part way through a run and the functions that have already cold started
+ * follow it.
+ */
+export class SimLambdaOutput {
+    #toHost = true;
+    /**
+     * Record function output to its log group alone.
+     *
+     * Lines written from then on stay out of the host console. Everything
+     * written before it is already printed.
+     */
+    captureOnly() {
+        this.#toHost = false;
+    }
+    /**
+     * Forward function output to the host console as well as recording it, which
+     * is what a simulated Lambda does until told otherwise.
+     */
+    teeToHost() {
+        this.#toHost = true;
+    }
+    /**
+     * Whether a recorded line still reaches the host console.
+     *
+     * Read by the two paths that write one, the vm sandbox's standard streams
+     * and the process globals a host-scope handler prints through.
+     * @internal
+     */
+    reachesHost() {
+        return this.#toHost;
+    }
+}

package/dist/service/lambda/function/outbound/sim-lambda-aws-api-outbound.d.ts

@@ -36,6 +36,7 @@ interface SimLambdaAwsApiOutboundProperties {
  */
 export declare class SimLambdaAwsApiOutbound implements SimLambdaOutboundHttp {
     private readonly dispatcher;
+    private readonly s3;
     constructor(properties: SimLambdaAwsApiOutboundProperties);
     /**
      * Whether a hostname is one of the AWS service API endpoints.
@@ -43,6 +44,13 @@ export declare class SimLambdaAwsApiOutbound implements SimLambdaOutboundHttp {
     serves(hostname: string): boolean;
     /**
      * Answer an AWS API request from the simulated operation it names.
+     *
+     * A request signed for S3 goes to the endpoint that reads S3's protocol,
+     * since S3 names its operation where the wire dispatcher looks for a header.
+     * No caller travels with it. The SDK signed it with the placeholder
+     * credentials the runtime puts in the environment, and the invocation is
+     * already running as the execution Role, the ambient caller every other call
+     * out of function code runs as.
      */
     fetch(request: Request): Promise<Response>;
 }

package/dist/service/lambda/function/outbound/sim-lambda-aws-api-outbound.js

@@ -1,5 +1,6 @@
 import { SimSdkWireDispatcher } from "../../../../sdk/wire/sim-sdk-wire-dispatcher.js";
 import { readSimSdkWireCredentialScope, readSimSdkWireOperation, } from "../../../../sdk/wire/sim-sdk-wire-operation.js";
+import { SimS3ApiEndpoint } from "../../../s3/serve/api/sim-s3-api.js";
 import { simLambdaOutboundWireRequest, simLambdaOutboundWireResponse, } from "./sim-lambda-outbound-wire.js";
 /**
  * The hostname suffixes AWS issues its service API endpoints under.
@@ -27,6 +28,17 @@ const awsEndpointSuffixes = [
  * way it answers for every other hostname a resource is issued.
  */
 const resourceEndpointLabel = ".execute-api.";
+/**
+ * The SigV4 signing name of the one service here whose requests an endpoint of
+ * its own reads.
+ *
+ * S3 states its operation in the method, the path and a query-string
+ * sub-resource. `SimS3ApiEndpoint` reads those. The signing name is where a
+ * signed request says which service it is for, whatever protocol that service
+ * speaks, and that is what selects the endpoint here, as it is on the served
+ * AWS API endpoint.
+ */
+const s3SigningName = "s3";
 /**
  * Whether a hostname is an AWS service API endpoint.
  */
@@ -64,8 +76,10 @@ export function isSimAwsApiRequest(request) {
  */
 export class SimLambdaAwsApiOutbound {
     dispatcher;
+    s3;
     constructor(properties) {
         this.dispatcher = new SimSdkWireDispatcher(properties.simAws, properties.regionName);
+        this.s3 = new SimS3ApiEndpoint({ simAws: properties.simAws });
     }
     /**
      * Whether a hostname is one of the AWS service API endpoints.
@@ -75,8 +89,20 @@ export class SimLambdaAwsApiOutbound {
     }
     /**
      * Answer an AWS API request from the simulated operation it names.
+     *
+     * A request signed for S3 goes to the endpoint that reads S3's protocol,
+     * since S3 names its operation where the wire dispatcher looks for a header.
+     * No caller travels with it. The SDK signed it with the placeholder
+     * credentials the runtime puts in the environment, and the invocation is
+     * already running as the execution Role, the ambient caller every other call
+     * out of function code runs as.
      */
     async fetch(request) {
-        return simLambdaOutboundWireResponse(await this.dispatcher.dispatch(await simLambdaOutboundWireRequest(request)));
+        const wireRequest = await simLambdaOutboundWireRequest(request);
+        const scope = readSimSdkWireCredentialScope(wireRequest);
+        if (scope?.signingName === s3SigningName) {
+            return await this.s3.handle(request, wireRequest.body, undefined, scope.regionName);
+        }
+        return simLambdaOutboundWireResponse(await this.dispatcher.dispatch(wireRequest));
     }
 }

package/dist/service/lambda/function/sim-lambda-function.d.ts

@@ -49,8 +49,8 @@ export declare class SimLambdaFunction {
     readonly metrics: SimLambdaFunctionMetrics;
     private readonly properties;
     private readonly runAsOwner;
-    private readonly runner;
     private readonly clock;
+    private readonly background;
     private readonly logging;
     private readonly outboundHttp;
     constructor(properties: SimLambdaFunctionProperties);

package/dist/service/lambda/function/sim-lambda-function.js

@@ -6,9 +6,8 @@ import { SimLambdaHandlerReferenceCode, } from "./code/sim-lambda-executable-cod
 import { SimLambdaEnvironment } from "./environment/sim-lambda-environment.js";
 import { SimLambdaFunctionLogging } from "./logging/sim-lambda-function-logging.js";
 import { SimLambdaFunctionPolicy } from "./policy/sim-lambda-function-policy.js";
-import { SimLambdaHandlerRunner } from "./invoke/sim-lambda-handler-runner.js";
+import { SimLambdaInvocation } from "./invoke/sim-lambda-invocation.js";
 import { SimLambdaFunctionMetrics } from "../metric/sim-lambda-function-metrics.js";
-import { SimLambdaInvokeContextBuilder } from "./invoke/sim-lambda-invoke-context-builder.js";
 import { runSimLambdaInHostScope } from "./invoke/sim-lambda-host-scope.js";
 import { SimRealClock } from "../../../util/clock/sim-clock.js";
 import { defaultLambdaHandler } from "./sim-lambda-handler.type.js";
@@ -56,14 +55,15 @@ export class SimLambdaFunction {
     #code;
     properties;
     runAsOwner;
-    runner = new SimLambdaHandlerRunner();
     clock;
+    background;
     logging;
     outboundHttp;
     constructor(properties) {
-        const { name, roleArn, accountRegionScope = simAwsAccountRegionScopeFactory.make(), handlerFunction = defaultLambdaHandler, code, state = "Pending", handlerName, runtimeName, description, timeoutSeconds = DEFAULT_SIM_LAMBDA_TIMEOUT_SECONDS, memorySizeMb = DEFAULT_SIM_LAMBDA_MEMORY_SIZE_MB, environment, deadLetterTargetArn, runAsOwner = this, version = SIM_LAMBDA_LATEST_VERSION, clock = new SimRealClock(), logs, metrics, outboundHttp, } = properties;
+        const { name, roleArn, accountRegionScope = simAwsAccountRegionScopeFactory.make(), handlerFunction = defaultLambdaHandler, code, state = "Pending", handlerName, runtimeName, description, timeoutSeconds = DEFAULT_SIM_LAMBDA_TIMEOUT_SECONDS, memorySizeMb = DEFAULT_SIM_LAMBDA_MEMORY_SIZE_MB, environment, deadLetterTargetArn, runAsOwner = this, version = SIM_LAMBDA_LATEST_VERSION, clock = new SimRealClock(), background, metrics, outboundHttp, } = properties;
         this.properties = properties;
         this.clock = clock;
+        this.background = background;
         this.version = version;
         this.name = name;
         this.roleArn = roleArn;
@@ -88,7 +88,8 @@ export class SimLambdaFunction {
         this.metrics = new SimLambdaFunctionMetrics({ metrics, clock });
         this.logging = new SimLambdaFunctionLogging({
             functionName: name,
-            logs,
+            logs: properties.logs,
+            output: properties.output,
             clock,
         });
     }
@@ -181,18 +182,19 @@ export class SimLambdaFunction {
      * Runtime.* cold-start error.
      */
     async invoke(event) {
-        const contextBuilder = new SimLambdaInvokeContextBuilder({
+        const invocation = new SimLambdaInvocation({
             functionName: this.name,
             functionVersion: this.version,
             invokedFunctionArn: this.arn,
             timeoutSeconds: this.timeoutSeconds,
             memorySizeMb: this.memorySizeMb,
             clock: this.clock,
+            background: this.background,
             logGroupName: this.logging.logGroupName,
             logStreamName: this.logging.logStreamName(),
         });
         this.logging.recordFrom(this.#code);
-        return await this.metrics.around(String(this.name), async () => simAwsRunAsContext.run(this.runAsOwner, { kind: "arn", arn: this.roleArn }, async () => await this.environment.runWith(async () => await this.runInHostScope(async () => await this.logging.around(async () => await this.runner.run(this.#code.handlerFunction(), event, contextBuilder))))));
+        return await this.metrics.around(String(this.name), async () => simAwsRunAsContext.run(this.runAsOwner, { kind: "arn", arn: this.roleArn }, async () => await this.environment.runWith(async () => await this.runInHostScope(async () => await this.logging.around(async () => await invocation.run(this.#code.handlerFunction(), event))))));
     }
     /**
      * Run an invocation with the process globals host-scope code reads bridged
@@ -204,7 +206,7 @@ export class SimLambdaFunction {
             return await run();
         }
         const { clock, outboundHttp } = this;
-        const output = this.logging.outputSink();
-        return await runSimLambdaInHostScope({ clock, outboundHttp, output }, run);
+        const scope = { clock, outboundHttp, ...this.logging.outputScope() };
+        return await runSimLambdaInHostScope(scope, run);
     }
 }

package/dist/service/lambda/function/sim-lambda-function.type.d.ts

@@ -1,8 +1,10 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
 import type { Brand } from "../../../util/brand.type.js";
 import type { SimClock } from "../../../util/clock/sim-clock.js";
 import type { SimAwsRunAsOwner } from "../../aws/caller/sim-aws-run-as-context.js";
 import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
 import type { SimCloudWatchServiceWriter } from "../../cloudwatch/write/sim-cloudwatch-service-writer.js";
+import type { SimLambdaOutput } from "./logging/sim-lambda-output.js";
 import type { SimLogsServiceWriter } from "../../logs/write/sim-logs-service-writer.js";
 import type { SimLambdaExecutableCode } from "./code/sim-lambda-executable-code.js";
 import type { SimLambdaEnvironment } from "./environment/sim-lambda-environment.js";
@@ -42,12 +44,25 @@ export interface SimLambdaFunctionProperties {
      * real clock.
      */
     clock?: SimClock | undefined;
+    /**
+     * Scheduler this function's handler timers and invocation deadline wait on.
+     * A function built standalone, outside a SimAws instance, has none, and its
+     * handler keeps the host timers and runs for as long as it likes.
+     */
+    background?: BackgroundScheduler | undefined;
     /**
      * Where this function's handler output is recorded. A function built
      * standalone, outside a SimAws instance, has nowhere to record to and writes
      * only to the host streams.
      */
     logs?: SimLogsServiceWriter | undefined;
+    /**
+     * Where this function's output goes besides its log group, shared with every
+     * other function of the same simulated Lambda. A function built standalone
+     * gets settings of its own, which nothing else can reach and which leave the
+     * host console printing.
+     */
+    output?: SimLambdaOutput | undefined;
     /**
      * Where this function's invocations are counted. A function built
      * standalone, outside a SimAws instance, has no simulated CloudWatch to

package/dist/service/lambda/function/url/sim-lambda-function-url-cors.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The cross-origin resource sharing settings of one Function URL.
+ *
+ * The member names are AWS's own. What `GetFunctionUrlConfig` reports is the
+ * record `CreateFunctionUrlConfig` was given.
+ *
+ * https://docs.aws.amazon.com/lambda/latest/api/API_Cors.html
+ */
+export interface SimLambdaFunctionUrlCors {
+    readonly AllowCredentials?: boolean | undefined;
+    readonly AllowHeaders?: readonly string[] | undefined;
+    readonly AllowMethods?: readonly string[] | undefined;
+    readonly AllowOrigins?: readonly string[] | undefined;
+    readonly ExposeHeaders?: readonly string[] | undefined;
+    readonly MaxAge?: number | undefined;
+}

package/dist/service/lambda/function/url/sim-lambda-function-url-cors.factory.d.ts

@@ -0,0 +1,22 @@
+import { DynamicFactory } from "@kensio/part-factory";
+/**
+ * A CORS configuration whose lists are mutable. That is the shape the AWS
+ * SDK's own command input takes, so a test can hand what this factory makes
+ * straight to a `CreateFunctionUrlConfigCommand`.
+ */
+export interface SimLambdaFunctionUrlCorsParts {
+    AllowCredentials: boolean;
+    AllowHeaders: string[];
+    AllowMethods: string[];
+    AllowOrigins: string[];
+    ExposeHeaders: string[];
+    MaxAge: number;
+}
+/**
+ * Makes a valid Function URL CORS configuration, so a test states only the
+ * part of it the test is about.
+ *
+ * The default allows one named Origin. That is the case where the headers
+ * served depend on the request that asked for them.
+ */
+export declare const simLambdaFunctionUrlCorsFactory: DynamicFactory<SimLambdaFunctionUrlCorsParts, undefined>;

package/dist/service/lambda/function/url/sim-lambda-function-url-cors.factory.js

@@ -0,0 +1,17 @@
+import { faker } from "@faker-js/faker";
+import { DynamicFactory } from "@kensio/part-factory";
+/**
+ * Makes a valid Function URL CORS configuration, so a test states only the
+ * part of it the test is about.
+ *
+ * The default allows one named Origin. That is the case where the headers
+ * served depend on the request that asked for them.
+ */
+export const simLambdaFunctionUrlCorsFactory = new DynamicFactory(() => ({
+    AllowCredentials: false,
+    AllowHeaders: ["content-type"],
+    AllowMethods: ["GET"],
+    AllowOrigins: [`https://${faker.internet.domainName()}`],
+    ExposeHeaders: ["x-request-id"],
+    MaxAge: faker.number.int({ min: 1, max: 86_400 }),
+}));

package/dist/service/lambda/function/url/sim-lambda-function-url-cors.js

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

package/dist/service/lambda/function/url/sim-lambda-function-url-factory.d.ts

@@ -1,6 +1,7 @@
 import type { SimAwsAccountRegionScope } from "../../../aws/sim-aws-account-region-scope.js";
 import type { SimLambdaUrlRegistry } from "../../registry/sim-lambda-url-registry.js";
 import type { SimLambdaFunction } from "../sim-lambda-function.js";
+import type { SimLambdaFunctionUrlCors } from "./sim-lambda-function-url-cors.js";
 import { SimLambdaFunctionUrl, type SimLambdaFunctionUrlAuthType, type SimLambdaFunctionUrlInvokeMode } from "./sim-lambda-function-url.js";
 import { type SimClock } from "../../../../util/clock/sim-clock.js";
 export interface SimLambdaFunctionUrlFactoryProperties {
@@ -12,6 +13,7 @@ interface MakeSimLambdaFunctionUrlProperties {
     readonly simFunction: SimLambdaFunction;
     readonly authType?: SimLambdaFunctionUrlAuthType | undefined;
     readonly invokeMode?: SimLambdaFunctionUrlInvokeMode | undefined;
+    readonly cors?: SimLambdaFunctionUrlCors | undefined;
 }
 /**
  * Builds Function URLs, taking their ids from the cross-Account registry.

package/dist/service/lambda/function/url/sim-lambda-function-url-factory.js

@@ -19,7 +19,7 @@ export class SimLambdaFunctionUrlFactory {
      * Make a registered Function URL for a function.
      */
     make(properties) {
-        const { simFunction, authType, invokeMode } = properties;
+        const { simFunction, authType, invokeMode, cors } = properties;
         const urlId = this.urlRegistry.allocateFunctionUrlId();
         this.urlRegistry.registerFunctionUrl(urlId, this.accountRegionScope.accountId);
         return new SimLambdaFunctionUrl({
@@ -29,6 +29,7 @@ export class SimLambdaFunctionUrlFactory {
             accountRegionScope: this.accountRegionScope,
             authType,
             invokeMode,
+            cors,
             clock: this.clock,
         });
     }

package/dist/service/lambda/function/url/sim-lambda-function-url-store.d.ts

@@ -1,10 +1,12 @@
 import type { SimLambdaFunction } from "../sim-lambda-function.js";
 import { type SimLambdaFunctionUrlFactoryProperties } from "./sim-lambda-function-url-factory.js";
+import type { SimLambdaFunctionUrlCors } from "./sim-lambda-function-url-cors.js";
 import type { SimLambdaFunctionUrl, SimLambdaFunctionUrlAuthType, SimLambdaFunctionUrlId, SimLambdaFunctionUrlInvokeMode } from "./sim-lambda-function-url.js";
 interface CreateSimLambdaFunctionUrlProperties {
     readonly simFunction: SimLambdaFunction;
     readonly authType?: SimLambdaFunctionUrlAuthType | undefined;
     readonly invokeMode?: SimLambdaFunctionUrlInvokeMode | undefined;
+    readonly cors?: SimLambdaFunctionUrlCors | undefined;
 }
 /**
  * Function URL state for one Account/Region scope of simulated Lambda.