@kensio/yulin 0.35.0 → 0.37.0

package/dist/service/lambda/serve/event/sim-lambda-url-event-builder.js

@@ -0,0 +1,61 @@
+import { SimLambdaUrlBodyEncoding } from "./sim-lambda-url-body-encoding.js";
+import { SimLambdaUrlRequestParts } from "./sim-lambda-url-request-parts.js";
+import { SimLambdaUrlRequestContextBuilder } from "./sim-lambda-url-request-context.js";
+import { SimRealClock, } from "../../../../util/clock/sim-clock.js";
+/**
+ * Builds the payload format 2.0 event a Function URL invocation passes to the
+ * function handler.
+ *
+ * Real Function URLs only speak payload format 2.0, so there is no version to
+ * choose. Request headers are passed through as received, including the local
+ * Host, while the requestContext describes the AWS-shaped endpoint the URL
+ * identifies and the caller, if any, that it authenticated.
+ */
+export class SimLambdaUrlEventBuilder {
+    bodyEncoding = new SimLambdaUrlBodyEncoding();
+    requestParts = new SimLambdaUrlRequestParts();
+    requestContext;
+    constructor(properties = {}) {
+        this.requestContext = new SimLambdaUrlRequestContextBuilder(properties.clock ?? new SimRealClock());
+    }
+    /**
+     * Build the invocation event for one Function URL request.
+     *
+     * A caller is supplied only when the Function URL authenticated one, which
+     * is what makes the authorizer block present for an `AWS_IAM` invocation and
+     * absent for a `NONE` one.
+     */
+    async build(request, functionUrl, authenticatedCaller) {
+        const url = new URL(request.url);
+        const bytes = new Uint8Array(await request.arrayBuffer());
+        const hasBody = bytes.length > 0;
+        const contentType = request.headers.get("content-type");
+        const event = {
+            version: "2.0",
+            routeKey: "$default",
+            rawPath: url.pathname,
+            rawQueryString: url.search.replace(/^\?/, ""),
+            headers: this.requestParts.headers(request),
+            requestContext: this.requestContext.build({
+                request,
+                url,
+                functionUrl,
+                authenticatedCaller,
+            }),
+            isBase64Encoded: hasBody && !this.bodyEncoding.isText(contentType),
+        };
+        const cookies = this.requestParts.cookies(request);
+        if (cookies.length > 0) {
+            event.cookies = cookies;
+        }
+        const queryStringParameters = this.requestParts.queryStringParameters(url);
+        if (Object.keys(queryStringParameters).length > 0) {
+            event.queryStringParameters = queryStringParameters;
+        }
+        if (hasBody) {
+            event.body = this.bodyEncoding.encode(bytes, contentType);
+        }
+        return event;
+    }
+}
+//# sourceMappingURL=sim-lambda-url-event-builder.js.map

package/dist/service/lambda/serve/event/sim-lambda-url-event-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-url-event-builder.js","sourceRoot":"","sources":["../../../../../src/service/lambda/serve/event/sim-lambda-url-event-builder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAE7E,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAE,iCAAiC,EAAE,MAAM,qCAAqC,CAAC;AAExF,OAAO,EAEL,YAAY,GACb,MAAM,qCAAqC,CAAC;AAU7C;;;;;;;;GAQG;AACH,MAAM,OAAO,wBAAwB;IAClB,YAAY,GAAG,IAAI,wBAAwB,EAAE,CAAC;IAC9C,YAAY,GAAG,IAAI,wBAAwB,EAAE,CAAC;IAC9C,cAAc,CAAoC;IAEnE,YAAY,UAAU,GAAuC,EAAE;QAC7D,IAAI,CAAC,cAAc,GAAG,IAAI,iCAAiC,CACzD,UAAU,CAAC,KAAK,IAAI,IAAI,YAAY,EAAE,CACvC,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,KAAK,CACT,OAAgB,EAChB,WAAiC,EACjC,mBAAyC;QAEzC,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACjC,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;QAC1D,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;QACjC,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QAExD,MAAM,KAAK,GAA8B;YACvC,OAAO,EAAE,KAAK;YACd,QAAQ,EAAE,UAAU;YACpB,OAAO,EAAE,GAAG,CAAC,QAAQ;YACrB,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;YAC7C,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC;YAC3C,cAAc,EAAE,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC;gBACxC,OAAO;gBACP,GAAG;gBACH,WAAW;gBACX,mBAAmB;aACpB,CAAC;YACF,eAAe,EAAE,OAAO,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,WAAW,CAAC;SACnE,CAAC;QAEF,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACnD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvB,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC;QAC1B,CAAC;QAED,MAAM,qBAAqB,GAAG,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,GAAG,CAAC,CAAC;QAC3E,IAAI,MAAM,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAClD,KAAK,CAAC,qBAAqB,GAAG,qBAAqB,CAAC;QACtD,CAAC;QAED,IAAI,OAAO,EAAE,CAAC;YACZ,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QAC5D,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;CACF"}

package/dist/service/lambda/serve/event/sim-lambda-url-event-time.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Format the time payload format 2.0 carries in requestContext.time.
+ *
+ * This is the Common Log Format stamp real Function URL events use, such as
+ * `12/Mar/2020:19:03:58 +0000`, always in UTC. The event's timeEpoch field is
+ * the same instant in milliseconds, for handlers that want to compute with it.
+ */
+export declare function simLambdaUrlEventTime(at: Date): string;
+//# sourceMappingURL=sim-lambda-url-event-time.d.ts.map

package/dist/service/lambda/serve/event/sim-lambda-url-event-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-url-event-time.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/serve/event/sim-lambda-url-event-time.ts"],"names":[],"mappings":"AAqBA;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,IAAI,GAAG,MAAM,CAatD"}

package/dist/service/lambda/serve/event/sim-lambda-url-event-time.js

@@ -0,0 +1,38 @@
+import { assertDefined } from "../../../../util/type-guard/defined.js";
+const months = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec",
+];
+function twoDigits(value) {
+    return String(value).padStart(2, "0");
+}
+/**
+ * Format the time payload format 2.0 carries in requestContext.time.
+ *
+ * This is the Common Log Format stamp real Function URL events use, such as
+ * `12/Mar/2020:19:03:58 +0000`, always in UTC. The event's timeEpoch field is
+ * the same instant in milliseconds, for handlers that want to compute with it.
+ */
+export function simLambdaUrlEventTime(at) {
+    const month = months[at.getUTCMonth()];
+    assertDefined(month, `Month name for ${at.toISOString()}`);
+    const year = String(at.getUTCFullYear());
+    const date = `${twoDigits(at.getUTCDate())}/${month}/${year}`;
+    const time = [
+        twoDigits(at.getUTCHours()),
+        twoDigits(at.getUTCMinutes()),
+        twoDigits(at.getUTCSeconds()),
+    ].join(":");
+    return `${date}:${time} +0000`;
+}
+//# sourceMappingURL=sim-lambda-url-event-time.js.map

package/dist/service/lambda/serve/event/sim-lambda-url-event-time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-url-event-time.js","sourceRoot":"","sources":["../../../../../src/service/lambda/serve/event/sim-lambda-url-event-time.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAEvE,MAAM,MAAM,GAAG;IACb,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;CACN,CAAC;AAEF,SAAS,SAAS,CAAC,KAAa;IAC9B,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,EAAQ;IAC5C,MAAM,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;IACvC,aAAa,CAAC,KAAK,EAAE,kBAAkB,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;IAE3D,MAAM,IAAI,GAAG,MAAM,CAAC,EAAE,CAAC,cAAc,EAAE,CAAC,CAAC;IACzC,MAAM,IAAI,GAAG,GAAG,SAAS,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;IAC9D,MAAM,IAAI,GAAG;QACX,SAAS,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC;QAC3B,SAAS,CAAC,EAAE,CAAC,aAAa,EAAE,CAAC;QAC7B,SAAS,CAAC,EAAE,CAAC,aAAa,EAAE,CAAC;KAC9B,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEZ,OAAO,GAAG,IAAI,IAAI,IAAI,QAAQ,CAAC;AACjC,CAAC"}

package/dist/service/lambda/serve/event/sim-lambda-url-event.type.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Lambda Function URL invocation event, in the API Gateway HTTP API payload
+ * format 2.0 that real Function URLs use.
+ *
+ * This is a minimal structural equivalent of the `aws-lambda` typings
+ * package's `LambdaFunctionURLEvent`, so handlers typed against that package
+ * can be invoked unchanged.
+ */
+export interface SimLambdaFunctionUrlEvent {
+    version: "2.0";
+    routeKey: "$default";
+    rawPath: string;
+    rawQueryString: string;
+    cookies?: string[];
+    headers: Record<string, string>;
+    queryStringParameters?: Record<string, string>;
+    requestContext: SimLambdaFunctionUrlRequestContext;
+    body?: string;
+    isBase64Encoded: boolean;
+}
+/**
+ * The requestContext block of a Function URL invocation event.
+ */
+export interface SimLambdaFunctionUrlRequestContext {
+    accountId: string;
+    apiId: string;
+    authorizer?: SimLambdaFunctionUrlAuthorizerContext;
+    domainName: string;
+    domainPrefix: string;
+    http: SimLambdaFunctionUrlHttpContext;
+    requestId: string;
+    routeKey: "$default";
+    stage: "$default";
+    time: string;
+    timeEpoch: number;
+}
+/**
+ * The requestContext.authorizer block, present only on an invocation a
+ * Function URL authenticated.
+ *
+ * A `NONE` Function URL is invokable by anyone and has no caller to describe,
+ * so real Lambda leaves this out entirely rather than filling it with blanks.
+ */
+export interface SimLambdaFunctionUrlAuthorizerContext {
+    iam: SimLambdaFunctionUrlIamAuthorizer;
+}
+/**
+ * The IAM caller of an `AWS_IAM` Function URL invocation.
+ *
+ * `userArn` and `accountId` describe the principal the request was attributed
+ * to, which is what makes a handler able to behave differently for different
+ * callers.
+ *
+ * `callerId` and `userId` carry the caller ARN rather than the opaque unique
+ * id (`AIDA...`, `AROA...:session`) real AWS puts there: the simulator has no
+ * unique-id namespace at the request boundary, and an ARN is what a test would
+ * assert on anyway. `accessKey` is empty, as the simulator does not carry the
+ * signing access key id past authentication. `cognitoIdentity` and
+ * `principalOrgId` are always null, as neither is simulated.
+ */
+export interface SimLambdaFunctionUrlIamAuthorizer {
+    accessKey: string;
+    accountId: string;
+    callerId: string;
+    cognitoIdentity: null;
+    principalOrgId: null;
+    userArn: string;
+    userId: string;
+}
+/**
+ * The requestContext.http block of a Function URL invocation event.
+ */
+export interface SimLambdaFunctionUrlHttpContext {
+    method: string;
+    path: string;
+    protocol: string;
+    sourceIp: string;
+    userAgent: string;
+}
+/**
+ * Structured handler result for a Function URL invocation.
+ *
+ * A handler may also return any other value, in which case real Lambda infers
+ * a 200 JSON response from it.
+ */
+export interface SimLambdaFunctionUrlResult extends SimLambdaFunctionUrlResultBody {
+    statusCode?: number | undefined;
+}
+/**
+ * A handler result that carries a status code, which is what makes real
+ * Lambda treat it as an HTTP response rather than a value to JSON-encode.
+ */
+export interface SimLambdaFunctionUrlStructuredResult extends SimLambdaFunctionUrlResultBody {
+    statusCode: number;
+}
+interface SimLambdaFunctionUrlResultBody {
+    headers?: Record<string, string | number | boolean> | undefined;
+    cookies?: string[] | undefined;
+    body?: string | undefined;
+    isBase64Encoded?: boolean | undefined;
+}
+export {};
+//# sourceMappingURL=sim-lambda-url-event.type.d.ts.map

package/dist/service/lambda/serve/event/sim-lambda-url-event.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-url-event.type.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/serve/event/sim-lambda-url-event.type.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,KAAK,CAAC;IACf,QAAQ,EAAE,UAAU,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,qBAAqB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/C,cAAc,EAAE,kCAAkC,CAAC;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,kCAAkC;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,qCAAqC,CAAC;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,+BAA+B,CAAC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,UAAU,CAAC;IACrB,KAAK,EAAE,UAAU,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,qCAAqC;IACpD,GAAG,EAAE,iCAAiC,CAAC;CACxC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,iCAAiC;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,IAAI,CAAC;IACtB,cAAc,EAAE,IAAI,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,MAAM,WAAW,0BAA2B,SAAQ,8BAA8B;IAChF,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC;AAED;;;GAGG;AACH,MAAM,WAAW,oCAAqC,SAAQ,8BAA8B;IAC1F,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,8BAA8B;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GAAG,SAAS,CAAC;IAChE,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC/B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,eAAe,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACvC"}

package/dist/service/lambda/serve/event/sim-lambda-url-event.type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sim-lambda-url-event.type.js.map

package/dist/service/lambda/serve/event/sim-lambda-url-event.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-url-event.type.js","sourceRoot":"","sources":["../../../../../src/service/lambda/serve/event/sim-lambda-url-event.type.ts"],"names":[],"mappings":""}

package/dist/service/lambda/serve/event/sim-lambda-url-iam-authorizer.d.ts

@@ -0,0 +1,30 @@
+import type { SimAwsRequestCaller } from "../../../iam/request/sim-aws-request-caller.js";
+import type { SimLambdaFunctionUrlAuthorizerContext } from "./sim-lambda-url-event.type.js";
+/**
+ * What a Function URL reports as the Account of a caller it did not
+ * authenticate, which is every caller of a `NONE` URL.
+ */
+export declare const simLambdaUrlAnonymousAccountId = "anonymous";
+/**
+ * How the caller of a Function URL invocation appears in the event.
+ *
+ * Real Lambda only ever authenticates an IAM principal at a Function URL, so
+ * everything here is derived from the caller's ARN. A caller without one is
+ * described the way an unauthenticated caller is, rather than filled in with
+ * something no real invocation would carry.
+ */
+export declare class SimLambdaUrlIamCaller {
+    private readonly caller;
+    constructor(caller: SimAwsRequestCaller);
+    /**
+     * The Account this invocation is reported as coming from.
+     */
+    accountId(): string;
+    /**
+     * The `requestContext.authorizer` block describing this caller, or undefined
+     * when there is no IAM principal to describe.
+     */
+    authorizerContext(): SimLambdaFunctionUrlAuthorizerContext | undefined;
+    private arn;
+}
+//# sourceMappingURL=sim-lambda-url-iam-authorizer.d.ts.map

package/dist/service/lambda/serve/event/sim-lambda-url-iam-authorizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-url-iam-authorizer.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/serve/event/sim-lambda-url-iam-authorizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gDAAgD,CAAC;AAC1F,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,gCAAgC,CAAC;AAE5F;;;GAGG;AACH,eAAO,MAAM,8BAA8B,cAAc,CAAC;AAE1D;;;;;;;GAOG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAE7C,YAAY,MAAM,EAAE,mBAAmB,EAEtC;IAED;;OAEG;IACH,SAAS,IAAI,MAAM,CAQlB;IAED;;;OAGG;IACH,iBAAiB,IAAI,qCAAqC,GAAG,SAAS,CAkBrE;IAED,OAAO,CAAC,GAAG;CAKZ"}

package/dist/service/lambda/serve/event/sim-lambda-url-iam-authorizer.js

@@ -0,0 +1,55 @@
+/**
+ * What a Function URL reports as the Account of a caller it did not
+ * authenticate, which is every caller of a `NONE` URL.
+ */
+export const simLambdaUrlAnonymousAccountId = "anonymous";
+/**
+ * How the caller of a Function URL invocation appears in the event.
+ *
+ * Real Lambda only ever authenticates an IAM principal at a Function URL, so
+ * everything here is derived from the caller's ARN. A caller without one is
+ * described the way an unauthenticated caller is, rather than filled in with
+ * something no real invocation would carry.
+ */
+export class SimLambdaUrlIamCaller {
+    caller;
+    constructor(caller) {
+        this.caller = caller;
+    }
+    /**
+     * The Account this invocation is reported as coming from.
+     */
+    accountId() {
+        const arnAccountId = this.arn()?.split(":", 6)[4];
+        if (arnAccountId === undefined || arnAccountId.length === 0) {
+            return simLambdaUrlAnonymousAccountId;
+        }
+        return arnAccountId;
+    }
+    /**
+     * The `requestContext.authorizer` block describing this caller, or undefined
+     * when there is no IAM principal to describe.
+     */
+    authorizerContext() {
+        const arn = this.arn();
+        if (arn === undefined) {
+            return undefined;
+        }
+        return {
+            iam: {
+                accessKey: "",
+                accountId: this.accountId(),
+                callerId: arn,
+                cognitoIdentity: null,
+                principalOrgId: null,
+                userArn: arn,
+                userId: arn,
+            },
+        };
+    }
+    arn() {
+        const { principal } = this.caller;
+        return principal.kind === "arn" ? principal.arn : undefined;
+    }
+}
+//# sourceMappingURL=sim-lambda-url-iam-authorizer.js.map

package/dist/service/lambda/serve/event/sim-lambda-url-iam-authorizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-url-iam-authorizer.js","sourceRoot":"","sources":["../../../../../src/service/lambda/serve/event/sim-lambda-url-iam-authorizer.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,WAAW,CAAC;AAE1D;;;;;;;GAOG;AACH,MAAM,OAAO,qBAAqB;IACf,MAAM,CAAsB;IAE7C,YAAY,MAA2B;QACrC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;OAEG;IACH,SAAS;QACP,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,EAAE,EAAE,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAElD,IAAI,YAAY,KAAK,SAAS,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5D,OAAO,8BAA8B,CAAC;QACxC,CAAC;QAED,OAAO,YAAY,CAAC;IACtB,CAAC;IAED;;;OAGG;IACH,iBAAiB;QACf,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAEvB,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACtB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO;YACL,GAAG,EAAE;gBACH,SAAS,EAAE,EAAE;gBACb,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE;gBAC3B,QAAQ,EAAE,GAAG;gBACb,eAAe,EAAE,IAAI;gBACrB,cAAc,EAAE,IAAI;gBACpB,OAAO,EAAE,GAAG;gBACZ,MAAM,EAAE,GAAG;aACZ;SACF,CAAC;IACJ,CAAC;IAEO,GAAG;QACT,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC;QAElC,OAAO,SAAS,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;IAC9D,CAAC;CACF"}

package/dist/service/lambda/serve/event/sim-lambda-url-request-context.d.ts

@@ -0,0 +1,29 @@
+import type { SimClock } from "../../../../util/clock/sim-clock.js";
+import type { SimAwsRequestCaller } from "../../../iam/request/sim-aws-request-caller.js";
+import type { SimLambdaFunctionUrl } from "../../function/url/sim-lambda-function-url.js";
+import type { SimLambdaFunctionUrlRequestContext } from "./sim-lambda-url-event.type.js";
+interface SimLambdaUrlRequestContextInput {
+    readonly request: Request;
+    readonly url: URL;
+    readonly functionUrl: SimLambdaFunctionUrl;
+    readonly authenticatedCaller?: SimAwsRequestCaller | undefined;
+}
+/**
+ * Builds the requestContext block of a Function URL invocation event.
+ *
+ * This describes the AWS-shaped endpoint the request reached and, when the
+ * Function URL authenticated one, the caller behind it. A caller is supplied
+ * only for an `AWS_IAM` invocation, which is what makes the authorizer block
+ * present there and absent for `NONE`, as it is on real AWS.
+ */
+export declare class SimLambdaUrlRequestContextBuilder {
+    private readonly clock;
+    constructor(clock: SimClock);
+    /**
+     * Build the requestContext for one Function URL request.
+     */
+    build(input: SimLambdaUrlRequestContextInput): SimLambdaFunctionUrlRequestContext;
+    private iamCaller;
+}
+export {};
+//# sourceMappingURL=sim-lambda-url-request-context.d.ts.map

package/dist/service/lambda/serve/event/sim-lambda-url-request-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-url-request-context.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/serve/event/sim-lambda-url-request-context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gDAAgD,CAAC;AAC1F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+CAA+C,CAAC;AAC1F,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,gCAAgC,CAAC;AAOzF,UAAU,+BAA+B;IACvC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,QAAQ,CAAC,mBAAmB,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CAChE;AAED;;;;;;;GAOG;AACH,qBAAa,iCAAiC;IAC5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;IAEjC,YAAY,KAAK,EAAE,QAAQ,EAE1B;IAED;;OAEG;IACH,KAAK,CACH,KAAK,EAAE,+BAA+B,GACrC,kCAAkC,CAgCpC;IAED,OAAO,CAAC,SAAS;CAKlB"}

package/dist/service/lambda/serve/event/sim-lambda-url-request-context.js

@@ -0,0 +1,54 @@
+import { randomUUID } from "node:crypto";
+import { simLambdaUrlEventTime } from "./sim-lambda-url-event-time.js";
+import { simLambdaUrlAnonymousAccountId, SimLambdaUrlIamCaller, } from "./sim-lambda-url-iam-authorizer.js";
+/**
+ * Builds the requestContext block of a Function URL invocation event.
+ *
+ * This describes the AWS-shaped endpoint the request reached and, when the
+ * Function URL authenticated one, the caller behind it. A caller is supplied
+ * only for an `AWS_IAM` invocation, which is what makes the authorizer block
+ * present there and absent for `NONE`, as it is on real AWS.
+ */
+export class SimLambdaUrlRequestContextBuilder {
+    clock;
+    constructor(clock) {
+        this.clock = clock;
+    }
+    /**
+     * Build the requestContext for one Function URL request.
+     */
+    build(input) {
+        const { request, url, functionUrl } = input;
+        const now = this.clock.now();
+        const iamCaller = this.iamCaller(input.authenticatedCaller);
+        const requestContext = {
+            // An unauthenticated Function URL request has no Account behind it, and
+            // that is what a Function URL calls anonymous.
+            accountId: iamCaller?.accountId() ?? simLambdaUrlAnonymousAccountId,
+            apiId: functionUrl.urlId,
+            domainName: functionUrl.hostname,
+            domainPrefix: functionUrl.urlId,
+            http: {
+                method: request.method,
+                path: url.pathname,
+                protocol: "HTTP/1.1",
+                sourceIp: "127.0.0.1",
+                userAgent: request.headers.get("user-agent") ?? "",
+            },
+            requestId: randomUUID(),
+            routeKey: "$default",
+            stage: "$default",
+            time: simLambdaUrlEventTime(now),
+            timeEpoch: now.getTime(),
+        };
+        const authorizer = iamCaller?.authorizerContext();
+        if (authorizer !== undefined) {
+            requestContext.authorizer = authorizer;
+        }
+        return requestContext;
+    }
+    iamCaller(caller) {
+        return caller === undefined ? undefined : new SimLambdaUrlIamCaller(caller);
+    }
+}
+//# sourceMappingURL=sim-lambda-url-request-context.js.map

package/dist/service/lambda/serve/event/sim-lambda-url-request-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-url-request-context.js","sourceRoot":"","sources":["../../../../../src/service/lambda/serve/event/sim-lambda-url-request-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAMzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EACL,8BAA8B,EAC9B,qBAAqB,GACtB,MAAM,oCAAoC,CAAC;AAS5C;;;;;;;GAOG;AACH,MAAM,OAAO,iCAAiC;IAC3B,KAAK,CAAW;IAEjC,YAAY,KAAe;QACzB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED;;OAEG;IACH,KAAK,CACH,KAAsC;QAEtC,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,KAAK,CAAC;QAC5C,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;QAC7B,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;QAE5D,MAAM,cAAc,GAAuC;YACzD,wEAAwE;YACxE,+CAA+C;YAC/C,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,8BAA8B;YACnE,KAAK,EAAE,WAAW,CAAC,KAAK;YACxB,UAAU,EAAE,WAAW,CAAC,QAAQ;YAChC,YAAY,EAAE,WAAW,CAAC,KAAK;YAC/B,IAAI,EAAE;gBACJ,MAAM,EAAE,OAAO,CAAC,MAAM;gBACtB,IAAI,EAAE,GAAG,CAAC,QAAQ;gBAClB,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,WAAW;gBACrB,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,EAAE;aACnD;YACD,SAAS,EAAE,UAAU,EAAE;YACvB,QAAQ,EAAE,UAAU;YACpB,KAAK,EAAE,UAAU;YACjB,IAAI,EAAE,qBAAqB,CAAC,GAAG,CAAC;YAChC,SAAS,EAAE,GAAG,CAAC,OAAO,EAAE;SACzB,CAAC;QAEF,MAAM,UAAU,GAAG,SAAS,EAAE,iBAAiB,EAAE,CAAC;QAClD,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,cAAc,CAAC,UAAU,GAAG,UAAU,CAAC;QACzC,CAAC;QAED,OAAO,cAAc,CAAC;IACxB,CAAC;IAEO,SAAS,CACf,MAAuC;QAEvC,OAAO,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,qBAAqB,CAAC,MAAM,CAAC,CAAC;IAC9E,CAAC;CACF"}

package/dist/service/lambda/serve/event/sim-lambda-url-request-parts.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Reads the parts of an HTTP request that payload format 2.0 delivers in its
+ * own event fields rather than as raw request data.
+ *
+ * Keeping this separate leaves the event builder to assemble the event from
+ * parts, without also owning the header, cookie and query conventions.
+ */
+export declare class SimLambdaUrlRequestParts {
+    /**
+     * Collect request headers, which payload format 2.0 delivers as single
+     * lowercased values.
+     *
+     * Cookies are left out because they travel in their own event field.
+     */
+    headers(request: Request): Record<string, string>;
+    /**
+     * Collect the request cookies as the separate list the event carries.
+     */
+    cookies(request: Request): string[];
+    /**
+     * Collect query string parameters, joining repeated keys with commas as
+     * payload format 2.0 does.
+     */
+    queryStringParameters(url: URL): Record<string, string>;
+}
+//# sourceMappingURL=sim-lambda-url-request-parts.d.ts.map

package/dist/service/lambda/serve/event/sim-lambda-url-request-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-url-request-parts.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/serve/event/sim-lambda-url-request-parts.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,wBAAwB;IACnC;;;;;OAKG;IACH,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAUhD;IAED;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAWlC;IAED;;;OAGG;IACH,qBAAqB,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAStD;CACF"}

package/dist/service/lambda/serve/event/sim-lambda-url-request-parts.js

@@ -0,0 +1,50 @@
+/**
+ * Reads the parts of an HTTP request that payload format 2.0 delivers in its
+ * own event fields rather than as raw request data.
+ *
+ * Keeping this separate leaves the event builder to assemble the event from
+ * parts, without also owning the header, cookie and query conventions.
+ */
+export class SimLambdaUrlRequestParts {
+    /**
+     * Collect request headers, which payload format 2.0 delivers as single
+     * lowercased values.
+     *
+     * Cookies are left out because they travel in their own event field.
+     */
+    headers(request) {
+        // Fetch API header names are already lowercased, which is the case
+        // payload format 2.0 delivers them in, and repeats are already joined.
+        const headers = new Map();
+        request.headers.forEach((value, name) => {
+            headers.set(name, value);
+        });
+        headers.delete("cookie");
+        return Object.fromEntries(headers);
+    }
+    /**
+     * Collect the request cookies as the separate list the event carries.
+     */
+    cookies(request) {
+        const cookieHeader = request.headers.get("cookie");
+        if (cookieHeader === null || cookieHeader.length === 0) {
+            return [];
+        }
+        return cookieHeader
+            .split(";")
+            .map((cookie) => cookie.trim())
+            .filter((cookie) => cookie.length > 0);
+    }
+    /**
+     * Collect query string parameters, joining repeated keys with commas as
+     * payload format 2.0 does.
+     */
+    queryStringParameters(url) {
+        const keys = new Set(url.searchParams.keys());
+        return Object.fromEntries([...keys].map((key) => [
+            key,
+            url.searchParams.getAll(key).join(","),
+        ]));
+    }
+}
+//# sourceMappingURL=sim-lambda-url-request-parts.js.map

package/dist/service/lambda/serve/event/sim-lambda-url-request-parts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-url-request-parts.js","sourceRoot":"","sources":["../../../../../src/service/lambda/serve/event/sim-lambda-url-request-parts.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,OAAO,wBAAwB;IACnC;;;;;OAKG;IACH,OAAO,CAAC,OAAgB;QACtB,mEAAmE;QACnE,uEAAuE;QACvE,MAAM,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;QAC1C,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;YACtC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;QACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAEzB,OAAO,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,OAAgB;QACtB,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAEnD,IAAI,YAAY,KAAK,IAAI,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvD,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,OAAO,YAAY;aAChB,KAAK,CAAC,GAAG,CAAC;aACV,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;aAC9B,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC3C,CAAC;IAED;;;OAGG;IACH,qBAAqB,CAAC,GAAQ;QAC5B,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC;QAE9C,OAAO,MAAM,CAAC,WAAW,CACvB,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAoB,EAAE,CAAC;YACvC,GAAG;YACH,GAAG,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;SACvC,CAAC,CACH,CAAC;IACJ,CAAC;CACF"}

package/dist/service/lambda/serve/response/sim-lambda-url-error-response.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The error responses a Function URL endpoint returns itself, before or
+ * instead of the function producing one.
+ *
+ * Real Lambda answers these with a small JSON document rather than the
+ * handler's output, so client code that reads the body of a failed Function
+ * URL call sees the same shape here.
+ */
+export declare class SimLambdaUrlErrorResponse {
+    /**
+     * No Function URL is served at this hostname.
+     */
+    notFound(): Response;
+    /**
+     * The Function URL requires authentication the simulator cannot verify.
+     */
+    forbidden(): Response;
+    /**
+     * The function failed to handle the invocation.
+     */
+    internalServerError(): Response;
+    private jsonResponse;
+}
+//# sourceMappingURL=sim-lambda-url-error-response.d.ts.map

package/dist/service/lambda/serve/response/sim-lambda-url-error-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-url-error-response.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/serve/response/sim-lambda-url-error-response.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,qBAAa,yBAAyB;IACpC;;OAEG;IACH,QAAQ,IAAI,QAAQ,CAEnB;IAED;;OAEG;IACH,SAAS,IAAI,QAAQ,CAEpB;IAED;;OAEG;IACH,mBAAmB,IAAI,QAAQ,CAE9B;IAED,OAAO,CAAC,YAAY;CASrB"}

package/dist/service/lambda/serve/response/sim-lambda-url-error-response.js

@@ -0,0 +1,35 @@
+/**
+ * The error responses a Function URL endpoint returns itself, before or
+ * instead of the function producing one.
+ *
+ * Real Lambda answers these with a small JSON document rather than the
+ * handler's output, so client code that reads the body of a failed Function
+ * URL call sees the same shape here.
+ */
+export class SimLambdaUrlErrorResponse {
+    /**
+     * No Function URL is served at this hostname.
+     */
+    notFound() {
+        return this.jsonResponse(404, "Not Found");
+    }
+    /**
+     * The Function URL requires authentication the simulator cannot verify.
+     */
+    forbidden() {
+        return this.jsonResponse(403, "Forbidden");
+    }
+    /**
+     * The function failed to handle the invocation.
+     */
+    internalServerError() {
+        return this.jsonResponse(502, "Internal Server Error");
+    }
+    jsonResponse(status, message) {
+        return Response.json({ Message: message }, {
+            status,
+            headers: { "content-type": "application/json" },
+        });
+    }
+}
+//# sourceMappingURL=sim-lambda-url-error-response.js.map

package/dist/service/lambda/serve/response/sim-lambda-url-error-response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-url-error-response.js","sourceRoot":"","sources":["../../../../../src/service/lambda/serve/response/sim-lambda-url-error-response.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,OAAO,yBAAyB;IACpC;;OAEG;IACH,QAAQ;QACN,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,mBAAmB;QACjB,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,uBAAuB,CAAC,CAAC;IACzD,CAAC;IAEO,YAAY,CAAC,MAAc,EAAE,OAAe;QAClD,OAAO,QAAQ,CAAC,IAAI,CAClB,EAAE,OAAO,EAAE,OAAO,EAAE,EACpB;YACE,MAAM;YACN,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;SAChD,CACF,CAAC;IACJ,CAAC;CACF"}

package/dist/service/lambda/serve/response/sim-lambda-url-response-builder.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Turns a Function URL handler result into the HTTP response the client sees.
+ *
+ * Real Lambda accepts two shapes here: a structured response carrying a
+ * statusCode, or any other value, which it wraps in a 200 JSON response. Both
+ * are supported so handlers written either way behave as they would on AWS.
+ */
+export declare class SimLambdaUrlResponseBuilder {
+    private readonly bodyEncoding;
+    /**
+     * Build the HTTP response for one handler result.
+     */
+    build(result: unknown): Response;
+    /**
+     * Whether the handler returned a structured HTTP response rather than a
+     * value to be JSON-encoded.
+     */
+    private isStructuredResult;
+    private structuredResponse;
+}
+//# sourceMappingURL=sim-lambda-url-response-builder.d.ts.map

package/dist/service/lambda/serve/response/sim-lambda-url-response-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-url-response-builder.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/serve/response/sim-lambda-url-response-builder.ts"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,qBAAa,2BAA2B;IACtC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAkC;IAE/D;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,CAS/B;IAED;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,kBAAkB;CAkC3B"}