@kensio/yulin 1.13.0 → 1.14.1

package/dist/service/elbv2/serve/sim-elbv2-request-parts.d.ts

@@ -0,0 +1,58 @@
+interface SimElbV2ProxiedRequest {
+    readonly request: Request;
+    /** The port the listener taking the request answers on. */
+    readonly port: number;
+    /** The protocol that listener speaks, lowercased for the header. */
+    readonly protocol: string;
+    readonly traceId: string;
+    readonly sourceIp: string;
+}
+/**
+ * Reads the parts of an HTTP request an ALB invocation event delivers in its
+ * own fields.
+ *
+ * Keeping this separate leaves the event builder to assemble the event from
+ * parts, without also owning the header and query conventions, which are ELB's
+ * own rather than either API Gateway payload format's.
+ */
+export declare class SimElbV2RequestParts {
+    /**
+     * Collect request headers, which an ALB event delivers as single lowercased
+     * values.
+     *
+     * Cookies stay in the `cookie` header they arrived in, unlike payload format
+     * 2.0, which lifts them into a field of their own. The four headers ELB adds
+     * are set rather than merged: ELB terminates the connection itself and
+     * writes them before the target sees them, so whatever a client sent under
+     * those names does not survive.
+     */
+    headers(proxied: SimElbV2ProxiedRequest): Record<string, string>;
+    /**
+     * Collect query string parameters, keeping the last value of a repeated key.
+     *
+     * The last-value rule is ELB's, and it is what the multi-value headers target
+     * group attribute exists to turn off. API Gateway joins repeated values with
+     * commas instead.
+     *
+     * The query string is read as it arrived rather than through URLSearchParams,
+     * because real ELB does not decode percent escapes and leaves decoding to the
+     * function. A handler therefore reads `a%2Bb` as it was sent, rather than the
+     * `a+b` that decoding it here would produce.
+     */
+    queryStringParameters(url: URL): Record<string, string>;
+    /**
+     * Split one query string pair, where a key on its own has an empty value.
+     */
+    private queryPair;
+    /**
+     * The `x-forwarded-for` header the target sees.
+     *
+     * Real ELB appends the client's address to whatever the request already
+     * carried, which is what makes the header a chain of proxies rather than one
+     * address. The other forwarding headers are overwritten, because those
+     * describe the connection this load balancer terminated.
+     */
+    private forwardedFor;
+}
+export {};
+//# sourceMappingURL=sim-elbv2-request-parts.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-request-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-request-parts.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-request-parts.ts"],"names":[],"mappings":"AAEA,UAAU,sBAAsB;IAC9B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,qBAAa,oBAAoB;IAC/B;;;;;;;;;OASG;IACH,OAAO,CAAC,OAAO,EAAE,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAkB/D;IAED;;;;;;;;;;;OAWG;IACH,qBAAqB,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAYtD;IAED;;OAEG;IACH,OAAO,CAAC,SAAS;IAQjB;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;CAYrB"}

package/dist/service/elbv2/serve/sim-elbv2-request-parts.js

@@ -0,0 +1,85 @@
+import { simAwsRequestHostname } from "../../../serve/http/url/sim-aws-request-hostname.js";
+/**
+ * Reads the parts of an HTTP request an ALB invocation event delivers in its
+ * own fields.
+ *
+ * Keeping this separate leaves the event builder to assemble the event from
+ * parts, without also owning the header and query conventions, which are ELB's
+ * own rather than either API Gateway payload format's.
+ */
+export class SimElbV2RequestParts {
+    /**
+     * Collect request headers, which an ALB event delivers as single lowercased
+     * values.
+     *
+     * Cookies stay in the `cookie` header they arrived in, unlike payload format
+     * 2.0, which lifts them into a field of their own. The four headers ELB adds
+     * are set rather than merged: ELB terminates the connection itself and
+     * writes them before the target sees them, so whatever a client sent under
+     * those names does not survive.
+     */
+    headers(proxied) {
+        // Fetch API header names are already lowercased, which is the case an ALB
+        // event delivers them in.
+        const headers = new Map();
+        proxied.request.headers.forEach((value, name) => {
+            headers.set(name, value);
+        });
+        // The host name the request named on real AWS, which is the load balancer's
+        // own DNS name or whatever Route53 name resolved to it, rather than the
+        // localhost one a served request arrived at.
+        headers.set("host", simAwsRequestHostname(proxied.request));
+        headers.set("x-amzn-trace-id", proxied.traceId);
+        headers.set("x-forwarded-for", this.forwardedFor(headers, proxied));
+        headers.set("x-forwarded-port", String(proxied.port));
+        headers.set("x-forwarded-proto", proxied.protocol.toLowerCase());
+        return Object.fromEntries(headers);
+    }
+    /**
+     * Collect query string parameters, keeping the last value of a repeated key.
+     *
+     * The last-value rule is ELB's, and it is what the multi-value headers target
+     * group attribute exists to turn off. API Gateway joins repeated values with
+     * commas instead.
+     *
+     * The query string is read as it arrived rather than through URLSearchParams,
+     * because real ELB does not decode percent escapes and leaves decoding to the
+     * function. A handler therefore reads `a%2Bb` as it was sent, rather than the
+     * `a+b` that decoding it here would produce.
+     */
+    queryStringParameters(url) {
+        const parameters = new Map();
+        for (const pair of url.search.replace(/^\?/u, "").split("&")) {
+            if (pair === "") {
+                continue;
+            }
+            parameters.set(...this.queryPair(pair, pair.indexOf("=")));
+        }
+        return Object.fromEntries(parameters);
+    }
+    /**
+     * Split one query string pair, where a key on its own has an empty value.
+     */
+    queryPair(pair, separator) {
+        if (separator === -1) {
+            return [pair, ""];
+        }
+        return [pair.slice(0, separator), pair.slice(separator + 1)];
+    }
+    /**
+     * The `x-forwarded-for` header the target sees.
+     *
+     * Real ELB appends the client's address to whatever the request already
+     * carried, which is what makes the header a chain of proxies rather than one
+     * address. The other forwarding headers are overwritten, because those
+     * describe the connection this load balancer terminated.
+     */
+    forwardedFor(headers, proxied) {
+        const forwarded = headers.get("x-forwarded-for");
+        if (forwarded === undefined || forwarded === "") {
+            return proxied.sourceIp;
+        }
+        return `${forwarded}, ${proxied.sourceIp}`;
+    }
+}
+//# sourceMappingURL=sim-elbv2-request-parts.js.map

package/dist/service/elbv2/serve/sim-elbv2-request-parts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-request-parts.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-request-parts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAY5F;;;;;;;GAOG;AACH,MAAM,OAAO,oBAAoB;IAC/B;;;;;;;;;OASG;IACH,OAAO,CAAC,OAA+B;QACrC,0EAA0E;QAC1E,0BAA0B;QAC1B,MAAM,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;QAC1C,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;YAC9C,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;QAEH,4EAA4E;QAC5E,wEAAwE;QACxE,6CAA6C;QAC7C,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QAC5D,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;QAChD,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;QACpE,OAAO,CAAC,GAAG,CAAC,kBAAkB,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;QACtD,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,OAAO,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC;QAEjE,OAAO,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;IAED;;;;;;;;;;;OAWG;IACH,qBAAqB,CAAC,GAAQ;QAC5B,MAAM,UAAU,GAAG,IAAI,GAAG,EAAkB,CAAC;QAE7C,KAAK,MAAM,IAAI,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;YAC7D,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;gBAChB,SAAS;YACX,CAAC;YAED,UAAU,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC7D,CAAC;QAED,OAAO,MAAM,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;IACxC,CAAC;IAED;;OAEG;IACK,SAAS,CAAC,IAAY,EAAE,SAAiB;QAC/C,IAAI,SAAS,KAAK,CAAC,CAAC,EAAE,CAAC;YACrB,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QACpB,CAAC;QAED,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC;IAC/D,CAAC;IAED;;;;;;;OAOG;IACK,YAAY,CAClB,OAAoC,EACpC,OAA+B;QAE/B,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;QAEjD,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,KAAK,EAAE,EAAE,CAAC;YAChD,OAAO,OAAO,CAAC,QAAQ,CAAC;QAC1B,CAAC;QAED,OAAO,GAAG,SAAS,KAAK,OAAO,CAAC,QAAQ,EAAE,CAAC;IAC7C,CAAC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-request-port.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The port a request reached a load balancer on.
+ *
+ * A URL naming no port means the scheme's own, which is what decides between
+ * an HTTP listener on 80 and an HTTPS one on 443 when a client writes neither.
+ *
+ * A request served under the Yulin-local suffix names the local server's port
+ * instead, which is a port no listener holds and which the client did not
+ * choose. That port belongs to the local transport rather than to the load
+ * balancer, so the scheme's own port is used for it too, and a request to
+ * `http://api.example.test.sim-aws.localhost:<port>/` reaches the listener on
+ * 80 as a request to `http://api.example.test/` would.
+ */
+export declare function simElbV2RequestPort(request: Request): number;
+//# sourceMappingURL=sim-elbv2-request-port.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-request-port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-request-port.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-request-port.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAY5D"}

package/dist/service/elbv2/serve/sim-elbv2-request-port.js

@@ -0,0 +1,34 @@
+import { isSimAwsLocalRequest } from "../../../serve/http/url/sim-aws-request-hostname.js";
+/**
+ * The port a request reached a load balancer on.
+ *
+ * A URL naming no port means the scheme's own, which is what decides between
+ * an HTTP listener on 80 and an HTTPS one on 443 when a client writes neither.
+ *
+ * A request served under the Yulin-local suffix names the local server's port
+ * instead, which is a port no listener holds and which the client did not
+ * choose. That port belongs to the local transport rather than to the load
+ * balancer, so the scheme's own port is used for it too, and a request to
+ * `http://api.example.test.sim-aws.localhost:<port>/` reaches the listener on
+ * 80 as a request to `http://api.example.test/` would.
+ */
+export function simElbV2RequestPort(request) {
+    const url = new URL(request.url);
+    if (isSimAwsLocalRequest(request)) {
+        return schemePort(url);
+    }
+    if (url.port !== "") {
+        return Number(url.port);
+    }
+    return schemePort(url);
+}
+/**
+ * The port a URL's scheme is served on when it names none of its own.
+ */
+function schemePort(url) {
+    if (url.protocol === "https:") {
+        return 443;
+    }
+    return 80;
+}
+//# sourceMappingURL=sim-elbv2-request-port.js.map

package/dist/service/elbv2/serve/sim-elbv2-request-port.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-request-port.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-request-port.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qDAAqD,CAAC;AAE3F;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,mBAAmB,CAAC,OAAgB;IAClD,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAEjC,IAAI,oBAAoB,CAAC,OAAO,CAAC,EAAE,CAAC;QAClC,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAED,IAAI,GAAG,CAAC,IAAI,KAAK,EAAE,EAAE,CAAC;QACpB,OAAO,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC;AACzB,CAAC;AAED;;GAEG;AACH,SAAS,UAAU,CAAC,GAAQ;IAC1B,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,GAAG,CAAC;IACb,CAAC;IAED,OAAO,EAAE,CAAC;AACZ,CAAC"}

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

@@ -0,0 +1,48 @@
+/**
+ * Turns what a Lambda target returned into the HTTP response the client sees.
+ *
+ * A load balancer takes one shape here, unlike API Gateway, which wraps
+ * anything unrecognised in a 200. A result with no usable status code is not a
+ * response ELB can send, so the client gets the load balancer's own 502 and
+ * never sees the handler's shape.
+ */
+export declare class SimElbV2ResponseBuilder {
+    private readonly bodyEncoding;
+    private readonly errorResponse;
+    /**
+     * Build the HTTP response for one handler result.
+     */
+    build(result: unknown): Response;
+    /**
+     * Whether the handler returned something a load balancer can send.
+     *
+     * The status code is the whole of the test, as it is on real ELB: anything
+     * else the result carries is optional, and a result without a status code in
+     * the range a response can hold is malformed.
+     */
+    private isResult;
+    /**
+     * Whether the response document is larger than a load balancer takes back.
+     *
+     * The whole document is measured, as real ELB measures it, so a body that is
+     * under the limit once decoded is still refused when its base64 and its
+     * headers put the response over.
+     */
+    private isTooLarge;
+    /**
+     * The body actually sent, which is nothing for a status that cannot hold
+     * one, and for an empty one.
+     */
+    private sendableBody;
+    /**
+     * The reason phrase the response carries.
+     *
+     * Real ELB takes a `statusDescription` such as `200 OK` and puts it in the
+     * status line, where the code is already. The code is therefore taken off
+     * again here, so a client reading the reason phrase finds `OK`, which is what
+     * it would read from a real load balancer.
+     */
+    private statusText;
+    private headers;
+}
+//# sourceMappingURL=sim-elbv2-response-builder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-response-builder.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-response-builder.ts"],"names":[],"mappings":"AAiCA;;;;;;;GAOG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA8B;IAC3D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA+B;IAE7D;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,CAoB/B;IAED;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ;IAehB;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAIlB;;;OAGG;IACH,OAAO,CAAC,YAAY;IAWpB;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;IAWlB,OAAO,CAAC,OAAO;CAYhB"}

package/dist/service/elbv2/serve/sim-elbv2-response-builder.js

@@ -0,0 +1,117 @@
+import { SimElbV2BodyEncoding } from "./sim-elbv2-body-encoding.js";
+import { SimElbV2ErrorResponse } from "./sim-elbv2-error-response.js";
+import { simElbV2NullBodyStatuses } from "./sim-elbv2-null-body-statuses.js";
+/**
+ * The largest response real ELB takes from a Lambda target.
+ *
+ * The limit is on the whole response document rather than on the body alone,
+ * so a base64 body counts at its encoded size and the headers count too.
+ */
+const maximumResponseBytes = 1024 * 1024;
+/**
+ * The response headers a load balancer writes itself rather than passing on.
+ *
+ * ELB does not honour hop-by-hop headers, and it computes the content length
+ * from the body it is about to send, so a handler naming any of these is
+ * naming something the load balancer decides.
+ */
+const loadBalancerOwnedHeaders = new Set([
+    "connection",
+    "content-length",
+    "keep-alive",
+    "transfer-encoding",
+]);
+/**
+ * Turns what a Lambda target returned into the HTTP response the client sees.
+ *
+ * A load balancer takes one shape here, unlike API Gateway, which wraps
+ * anything unrecognised in a 200. A result with no usable status code is not a
+ * response ELB can send, so the client gets the load balancer's own 502 and
+ * never sees the handler's shape.
+ */
+export class SimElbV2ResponseBuilder {
+    bodyEncoding = new SimElbV2BodyEncoding();
+    errorResponse = new SimElbV2ErrorResponse();
+    /**
+     * Build the HTTP response for one handler result.
+     */
+    build(result) {
+        if (!this.isResult(result)) {
+            return this.errorResponse.badGateway();
+        }
+        if (this.isTooLarge(result)) {
+            return this.errorResponse.badGateway();
+        }
+        const statusCode = result.statusCode;
+        const body = this.bodyEncoding.decode(result.body ?? "", result.isBase64Encoded ?? false);
+        return new Response(this.sendableBody(statusCode, body), {
+            status: statusCode,
+            statusText: this.statusText(result, statusCode),
+            headers: this.headers(result),
+        });
+    }
+    /**
+     * Whether the handler returned something a load balancer can send.
+     *
+     * The status code is the whole of the test, as it is on real ELB: anything
+     * else the result carries is optional, and a result without a status code in
+     * the range a response can hold is malformed.
+     */
+    isResult(result) {
+        if (typeof result !== "object" || result === null) {
+            return false;
+        }
+        const statusCode = result.statusCode;
+        return (Number.isSafeInteger(statusCode) &&
+            typeof statusCode === "number" &&
+            statusCode >= 200 &&
+            statusCode <= 599);
+    }
+    /**
+     * Whether the response document is larger than a load balancer takes back.
+     *
+     * The whole document is measured, as real ELB measures it, so a body that is
+     * under the limit once decoded is still refused when its base64 and its
+     * headers put the response over.
+     */
+    isTooLarge(result) {
+        return Buffer.byteLength(JSON.stringify(result)) > maximumResponseBytes;
+    }
+    /**
+     * The body actually sent, which is nothing for a status that cannot hold
+     * one, and for an empty one.
+     */
+    sendableBody(statusCode, body) {
+        if (simElbV2NullBodyStatuses.has(statusCode) || body.length === 0) {
+            return null;
+        }
+        return body;
+    }
+    /**
+     * The reason phrase the response carries.
+     *
+     * Real ELB takes a `statusDescription` such as `200 OK` and puts it in the
+     * status line, where the code is already. The code is therefore taken off
+     * again here, so a client reading the reason phrase finds `OK`, which is what
+     * it would read from a real load balancer.
+     */
+    statusText(result, statusCode) {
+        const description = result.statusDescription ?? "";
+        const prefix = `${String(statusCode)} `;
+        if (description.startsWith(prefix)) {
+            return description.slice(prefix.length);
+        }
+        return description;
+    }
+    headers(result) {
+        const headers = new Headers();
+        const named = Object.entries(result.headers ?? {});
+        for (const [name, value] of named) {
+            if (!loadBalancerOwnedHeaders.has(name.toLowerCase())) {
+                headers.set(name, value);
+            }
+        }
+        return headers;
+    }
+}
+//# sourceMappingURL=sim-elbv2-response-builder.js.map

package/dist/service/elbv2/serve/sim-elbv2-response-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-response-builder.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-response-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAEtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAE7E;;;;;GAKG;AACH,MAAM,oBAAoB,GAAG,IAAI,GAAG,IAAI,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,wBAAwB,GAAwB,IAAI,GAAG,CAAC;IAC5D,YAAY;IACZ,gBAAgB;IAChB,YAAY;IACZ,mBAAmB;CACpB,CAAC,CAAC;AAQH;;;;;;;GAOG;AACH,MAAM,OAAO,uBAAuB;IACjB,YAAY,GAAG,IAAI,oBAAoB,EAAE,CAAC;IAC1C,aAAa,GAAG,IAAI,qBAAqB,EAAE,CAAC;IAE7D;;OAEG;IACH,KAAK,CAAC,MAAe;QACnB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,CAAC;QACzC,CAAC;QAED,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,CAAC;QACzC,CAAC;QAED,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;QACrC,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CACnC,MAAM,CAAC,IAAI,IAAI,EAAE,EACjB,MAAM,CAAC,eAAe,IAAI,KAAK,CAChC,CAAC;QAEF,OAAO,IAAI,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE;YACvD,MAAM,EAAE,UAAU;YAClB,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,CAAC;YAC/C,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;SAC9B,CAAC,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACK,QAAQ,CAAC,MAAe;QAC9B,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;YAClD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,UAAU,GAAI,MAAyB,CAAC,UAAU,CAAC;QAEzD,OAAO,CACL,MAAM,CAAC,aAAa,CAAC,UAAU,CAAC;YAChC,OAAO,UAAU,KAAK,QAAQ;YAC9B,UAAU,IAAI,GAAG;YACjB,UAAU,IAAI,GAAG,CAClB,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACK,UAAU,CAAC,MAA8B;QAC/C,OAAO,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,oBAAoB,CAAC;IAC1E,CAAC;IAED;;;OAGG;IACK,YAAY,CAClB,UAAkB,EAClB,IAAyB;QAEzB,IAAI,wBAAwB,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAClE,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;OAOG;IACK,UAAU,CAAC,MAAsB,EAAE,UAAkB;QAC3D,MAAM,WAAW,GAAG,MAAM,CAAC,iBAAiB,IAAI,EAAE,CAAC;QACnD,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC;QAExC,IAAI,WAAW,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YACnC,OAAO,WAAW,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC1C,CAAC;QAED,OAAO,WAAW,CAAC;IACrB,CAAC;IAEO,OAAO,CAAC,MAAsB;QACpC,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;QAC9B,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC;QAEnD,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,KAAK,EAAE,CAAC;YAClC,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC;gBACtD,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAC3B,CAAC;QACH,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-router.d.ts

@@ -0,0 +1,81 @@
+import type { SimAwsServiceTarget } from "../../../serve/controller/sim-service-controller.js";
+import type { SimAws } from "../../aws/sim-aws.js";
+import type { SimEcsContainerServer } from "../../ecs/service/serve/sim-ecs-container-server.js";
+import type { SimIamInterServiceAuthZ } from "../../iam/authorize/sim-iam-inter-service-auth-z.js";
+import type { SimLambdaFunction } from "../../lambda/function/sim-lambda-function.js";
+import type { SimElbV2LoadBalancer } from "../load-balancer/sim-elbv2-load-balancer.js";
+import type { SimElbV2 } from "../sim-elbv2.js";
+import type { SimElbV2TargetGroup } from "../target-group/sim-elbv2-target-group.js";
+interface SimElbV2RouterProperties {
+    /**
+     * The simulation to route within. Required, because a router with a
+     * simulation of its own would find no load balancer anything created.
+     */
+    readonly simAws: SimAws;
+}
+/**
+ * A load balancer a request reached, and the scope it lives in.
+ */
+export interface SimElbV2LoadBalancerRoute {
+    readonly loadBalancer: SimElbV2LoadBalancer;
+    readonly elbV2: SimElbV2;
+}
+/**
+ * A function a target group invokes, and what decides whether it may.
+ */
+export interface SimElbV2FunctionTarget {
+    readonly simFunction: SimLambdaFunction;
+    /**
+     * IAM of the Account owning the function, which is what the load balancer's
+     * invoke permission is evaluated against.
+     */
+    readonly iam: SimIamInterServiceAuthZ;
+}
+/**
+ * Routes a request to the load balancer behind its host name, and a target
+ * group to the function or container behind that.
+ *
+ * A host name names nothing but itself, while simulated ELBv2 state is per
+ * Account and Region, and the registry is the hop between the two. What a
+ * target group holds is not a second hop: real ELB requires a Lambda target to
+ * be in the same Account and Region as its target group, and simulated ECS
+ * refuses a service a target group outside its own, so the target group's own
+ * scope is the only one either is looked for in.
+ */
+export declare class SimElbV2Router {
+    /**
+     * The simulation this router routes within.
+     *
+     * Exposed so collaborators needing the same simulation, such as the clock
+     * stamping invocation events, take it from here rather than being given a
+     * second SimAws that could be a different one.
+     */
+    readonly simAws: SimAws;
+    private readonly registry;
+    constructor(properties: SimElbV2RouterProperties);
+    /**
+     * Find the load balancer a request target addresses.
+     */
+    route(target: SimAwsServiceTarget): SimElbV2LoadBalancerRoute | undefined;
+    /**
+     * Find the function registered in a target group, and the IAM deciding
+     * whether the load balancer may invoke it.
+     *
+     * A target naming another Account or Region finds nothing. Real ELB refuses
+     * to register one at all, so answering as though it were there would be the
+     * looser of the two behaviours.
+     */
+    functionFor(targetGroup: SimElbV2TargetGroup): SimElbV2FunctionTarget | undefined;
+    /**
+     * Find the container of a simulated ECS service that answers for a target
+     * group.
+     *
+     * Which service that is, and which of its containers, is simulated ECS's
+     * question rather than this one's: a service is what registered into the
+     * group, and what is bound to its containers is what decides whether any of
+     * them can answer.
+     */
+    containerFor(targetGroup: SimElbV2TargetGroup): SimEcsContainerServer | undefined;
+}
+export {};
+//# sourceMappingURL=sim-elbv2-router.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-router.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qDAAqD,CAAC;AAE/F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AACjG,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qDAAqD,CAAC;AAEnG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AACtF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6CAA6C,CAAC;AAExF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAErF,UAAU,wBAAwB;IAChC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAC;IAC5C,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,WAAW,EAAE,iBAAiB,CAAC;IACxC;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,uBAAuB,CAAC;CACvC;AAED;;;;;;;;;;GAUG;AACH,qBAAa,cAAc;IACzB;;;;;;OAMG;IACH,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAE5C,YAAY,UAAU,EAAE,wBAAwB,EAG/C;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,mBAAmB,GAAG,yBAAyB,GAAG,SAAS,CAqBxE;IAED;;;;;;;OAOG;IACH,WAAW,CACT,WAAW,EAAE,mBAAmB,GAC/B,sBAAsB,GAAG,SAAS,CAiCpC;IAED;;;;;;;;OAQG;IACH,YAAY,CACV,WAAW,EAAE,mBAAmB,GAC/B,qBAAqB,GAAG,SAAS,CAOnC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-router.js

@@ -0,0 +1,92 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { parseSimLambdaFunctionArn } from "../../lambda/function/sim-lambda-function-arn-parts.js";
+/**
+ * Routes a request to the load balancer behind its host name, and a target
+ * group to the function or container behind that.
+ *
+ * A host name names nothing but itself, while simulated ELBv2 state is per
+ * Account and Region, and the registry is the hop between the two. What a
+ * target group holds is not a second hop: real ELB requires a Lambda target to
+ * be in the same Account and Region as its target group, and simulated ECS
+ * refuses a service a target group outside its own, so the target group's own
+ * scope is the only one either is looked for in.
+ */
+export class SimElbV2Router {
+    /**
+     * The simulation this router routes within.
+     *
+     * Exposed so collaborators needing the same simulation, such as the clock
+     * stamping invocation events, take it from here rather than being given a
+     * second SimAws that could be a different one.
+     */
+    simAws;
+    registry;
+    constructor(properties) {
+        this.simAws = properties.simAws;
+        this.registry = this.simAws.serviceFactory.elbV2Registry;
+    }
+    /**
+     * Find the load balancer a request target addresses.
+     */
+    route(target) {
+        const scope = this.registry.scopeForDnsName(target.resourceName);
+        if (scope === undefined) {
+            return undefined;
+        }
+        const elbV2 = this.simAws
+            .accountRegionScope(scope.accountId, scope.regionName)
+            .elbV2();
+        const loadBalancer = elbV2.findLoadBalancerByDnsName(target.resourceName);
+        // A registered DNS name is one that scope's own store holds, because the
+        // store is what registers and deregisters it.
+        assertDefined(loadBalancer, `${scope.accountId} in ${scope.regionName} is registered for the load ` +
+            `balancer DNS name ${target.resourceName} and does not hold it`);
+        return { loadBalancer, elbV2 };
+    }
+    /**
+     * Find the function registered in a target group, and the IAM deciding
+     * whether the load balancer may invoke it.
+     *
+     * A target naming another Account or Region finds nothing. Real ELB refuses
+     * to register one at all, so answering as though it were there would be the
+     * looser of the two behaviours.
+     */
+    functionFor(targetGroup) {
+        const target = targetGroup.registeredTargets[0];
+        // A group with nothing in it never gets here: that is the 503 the load
+        // balancer answers before it looks for a function.
+        assertDefined(target, `Target group ${targetGroup.name} has no registered target`);
+        const parts = parseSimLambdaFunctionArn(target.id);
+        const { accountId, regionName } = targetGroup.accountRegionScope;
+        // A lambda target group refuses anything but a function ARN when the
+        // target is registered, so a registered one is always readable.
+        assertDefined(parts, `Target '${target.id}' in target group ${targetGroup.name} is not a ` +
+            `Lambda function ARN`);
+        if (parts.accountId !== accountId || parts.regionName !== regionName) {
+            return undefined;
+        }
+        const scope = this.simAws.accountRegionScope(accountId, regionName);
+        const simFunction = scope.lambda().getSimFunctionByName(parts.functionName);
+        if (simFunction === undefined) {
+            return undefined;
+        }
+        return { simFunction, iam: scope.iam() };
+    }
+    /**
+     * Find the container of a simulated ECS service that answers for a target
+     * group.
+     *
+     * Which service that is, and which of its containers, is simulated ECS's
+     * question rather than this one's: a service is what registered into the
+     * group, and what is bound to its containers is what decides whether any of
+     * them can answer.
+     */
+    containerFor(targetGroup) {
+        const { accountId, regionName } = targetGroup.accountRegionScope;
+        return this.simAws
+            .accountRegionScope(accountId, regionName)
+            .ecs()
+            .servingContainer(targetGroup.arn);
+    }
+}
+//# sourceMappingURL=sim-elbv2-router.js.map

package/dist/service/elbv2/serve/sim-elbv2-router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-router.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-router.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAIpE,OAAO,EAAE,yBAAyB,EAAE,MAAM,wDAAwD,CAAC;AAmCnG;;;;;;;;;;GAUG;AACH,MAAM,OAAO,cAAc;IACzB;;;;;;OAMG;IACa,MAAM,CAAS;IAEd,QAAQ,CAAmB;IAE5C,YAAY,UAAoC;QAC9C,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;QAChC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,aAAa,CAAC;IAC3D,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAA2B;QAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAEjE,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM;aACtB,kBAAkB,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,UAAU,CAAC;aACrD,KAAK,EAAE,CAAC;QACX,MAAM,YAAY,GAAG,KAAK,CAAC,yBAAyB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAE1E,yEAAyE;QACzE,8CAA8C;QAC9C,aAAa,CACX,YAAY,EACZ,GAAG,KAAK,CAAC,SAAS,OAAO,KAAK,CAAC,UAAU,8BAA8B;YACrE,qBAAqB,MAAM,CAAC,YAAY,uBAAuB,CAClE,CAAC;QAEF,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC;IACjC,CAAC;IAED;;;;;;;OAOG;IACH,WAAW,CACT,WAAgC;QAEhC,MAAM,MAAM,GAAG,WAAW,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;QAEhD,uEAAuE;QACvE,mDAAmD;QACnD,aAAa,CACX,MAAM,EACN,gBAAgB,WAAW,CAAC,IAAI,2BAA2B,CAC5D,CAAC;QAEF,MAAM,KAAK,GAAG,yBAAyB,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACnD,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,WAAW,CAAC,kBAAkB,CAAC;QAEjE,qEAAqE;QACrE,gEAAgE;QAChE,aAAa,CACX,KAAK,EACL,WAAW,MAAM,CAAC,EAAE,qBAAqB,WAAW,CAAC,IAAI,YAAY;YACnE,qBAAqB,CACxB,CAAC;QAEF,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS,IAAI,KAAK,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;YACrE,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;QACpE,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,oBAAoB,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAE5E,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE,EAAE,CAAC;IAC3C,CAAC;IAED;;;;;;;;OAQG;IACH,YAAY,CACV,WAAgC;QAEhC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,WAAW,CAAC,kBAAkB,CAAC;QAEjE,OAAO,IAAI,CAAC,MAAM;aACf,kBAAkB,CAAC,SAAS,EAAE,UAAU,CAAC;aACzC,GAAG,EAAE;aACL,gBAAgB,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACvC,CAAC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-rule-evaluation.d.ts

@@ -0,0 +1,37 @@
+import type { SimElbV2Action } from "../action/sim-elbv2-action.js";
+import type { SimElbV2Listener } from "../listener/sim-elbv2-listener.js";
+import type { SimElbV2 } from "../sim-elbv2.js";
+/**
+ * The action answering one request, and what it came from.
+ *
+ * The source is carried so a refusal can name the rule or listener holding the
+ * action rather than only the action itself, which is the part a reader has to
+ * go and change.
+ */
+export declare class SimElbV2MatchedAction {
+    readonly action: SimElbV2Action;
+    readonly source: string;
+    constructor(action: SimElbV2Action, source: string);
+}
+/**
+ * Chooses the action a listener answers a request with.
+ *
+ * Rules are evaluated in priority order, lowest number first, and the first one
+ * whose conditions all hold claims the request. A later rule that would also
+ * have matched never sees it, which is what makes priority the thing worth
+ * getting right. A request no rule claims falls through to the listener's
+ * default action, which is the rule real ELB reports as `default`.
+ */
+export declare class SimElbV2RuleEvaluation {
+    private readonly elbV2;
+    constructor(elbV2: SimElbV2);
+    /**
+     * The action answering one request on one listener.
+     */
+    actionFor(listener: SimElbV2Listener, request: Request): SimElbV2MatchedAction;
+    /**
+     * The one action a listener or rule holds.
+     */
+    private only;
+}
+//# sourceMappingURL=sim-elbv2-rule-evaluation.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-rule-evaluation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-rule-evaluation.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-rule-evaluation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAEpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;;;GAMG;AACH,qBAAa,qBAAqB;aAEd,MAAM,EAAE,cAAc;aACtB,MAAM,EAAE,MAAM;IAFhC,YACkB,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,MAAM,EAC5B;CACL;AAED;;;;;;;;GAQG;AACH,qBAAa,sBAAsB;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAAlC,YAA6B,KAAK,EAAE,QAAQ,EAAI;IAEhD;;OAEG;IACH,SAAS,CACP,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,OAAO,GACf,qBAAqB,CAWvB;IAED;;OAEG;IACH,OAAO,CAAC,IAAI;CAYb"}