@kensio/yulin 1.12.1 → 1.14.0

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

@@ -0,0 +1,26 @@
+import { SimAwsServiceRequest } from "../../../serve/controller/sim-service-controller.js";
+import { SimElbV2ServiceController } from "./sim-elbv2-controller.js";
+/**
+ * Send an HTTP request to whichever simulated load balancer its host name
+ * names.
+ *
+ * This is the in-process way to reach a load balancer, taking the same
+ * arguments as `fetch`. The host name of the URL is the load balancer's DNS
+ * name and the port is the listener's, which is what a client writes on real
+ * AWS too. Nothing is sent over a socket.
+ *
+ * A host name no load balancer answers on, and a port no listener holds, both
+ * throw rather than answering: on real AWS neither reaches a load balancer at
+ * all, so there is no status for either.
+ */
+export async function simElbV2Fetch(simAws, input, init) {
+    const request = new Request(input, init);
+    return await new SimElbV2ServiceController({ simAws }).handleRequest(new SimAwsServiceRequest({
+        target: {
+            service: "elbV2",
+            resourceName: new URL(request.url).hostname,
+        },
+        request,
+    }));
+}
+//# sourceMappingURL=sim-elbv2-fetch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-fetch.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qDAAqD,CAAC;AAE3F,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAEtE;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,MAAc,EACd,KAAuB,EACvB,IAAkB;IAElB,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAEzC,OAAO,MAAM,IAAI,yBAAyB,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,aAAa,CAClE,IAAI,oBAAoB,CAAC;QACvB,MAAM,EAAE;YACN,OAAO,EAAE,OAAO;YAChB,YAAY,EAAE,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,QAAQ;SAC5C;QACD,OAAO;KACR,CAAC,CACH,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,27 @@
+import type { SimElbV2Action } from "../action/sim-elbv2-action.js";
+/**
+ * Answers a request with a listener or rule's `fixed-response` action.
+ *
+ * No target is involved and none is needed, which is what makes this the usual
+ * way to serve a health endpoint or a maintenance page. The load balancer
+ * writes the response itself from what the action holds.
+ */
+export declare class SimElbV2FixedResponse {
+    /**
+     * Build the response one fixed-response action sends.
+     */
+    respond(action: SimElbV2Action): Response;
+    /**
+     * The body actually sent, which is nothing for a status that cannot hold
+     * one, and for a configuration naming none.
+     */
+    private body;
+    /**
+     * The response headers, which are the content type or nothing.
+     *
+     * Real ELB sends no content type when the action names none, rather than
+     * guessing one from the body.
+     */
+    private headers;
+}
+//# sourceMappingURL=sim-elbv2-fixed-response.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-fixed-response.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-fixed-response.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAIpE;;;;;;GAMG;AACH,qBAAa,qBAAqB;IAChC;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,cAAc,GAAG,QAAQ,CAgBxC;IAED;;;OAGG;IACH,OAAO,CAAC,IAAI;IAaZ;;;;;OAKG;IACH,OAAO,CAAC,OAAO;CAShB"}

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

@@ -0,0 +1,50 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { simElbV2NullBodyStatuses } from "./sim-elbv2-null-body-statuses.js";
+/**
+ * Answers a request with a listener or rule's `fixed-response` action.
+ *
+ * No target is involved and none is needed, which is what makes this the usual
+ * way to serve a health endpoint or a maintenance page. The load balancer
+ * writes the response itself from what the action holds.
+ */
+export class SimElbV2FixedResponse {
+    /**
+     * Build the response one fixed-response action sends.
+     */
+    respond(action) {
+        const config = action.fixedResponse;
+        // A fixed-response action is created with a configuration and a status
+        // code, so a stored one always has both.
+        assertDefined(config, `Simulated ELBv2 fixed-response action holds no FixedResponseConfig`);
+        const status = Number(config.StatusCode);
+        return new Response(this.body(config, status), {
+            status,
+            headers: this.headers(config),
+        });
+    }
+    /**
+     * The body actually sent, which is nothing for a status that cannot hold
+     * one, and for a configuration naming none.
+     */
+    body(config, status) {
+        const message = config.MessageBody ?? "";
+        if (message === "" || simElbV2NullBodyStatuses.has(status)) {
+            return null;
+        }
+        return message;
+    }
+    /**
+     * The response headers, which are the content type or nothing.
+     *
+     * Real ELB sends no content type when the action names none, rather than
+     * guessing one from the body.
+     */
+    headers(config) {
+        const headers = new Headers();
+        if (config.ContentType !== undefined) {
+            headers.set("content-type", config.ContentType);
+        }
+        return headers;
+    }
+}
+//# sourceMappingURL=sim-elbv2-fixed-response.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-fixed-response.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-fixed-response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAGpE,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAE7E;;;;;;GAMG;AACH,MAAM,OAAO,qBAAqB;IAChC;;OAEG;IACH,OAAO,CAAC,MAAsB;QAC5B,MAAM,MAAM,GAAG,MAAM,CAAC,aAAa,CAAC;QAEpC,uEAAuE;QACvE,yCAAyC;QACzC,aAAa,CACX,MAAM,EACN,oEAAoE,CACrE,CAAC;QAEF,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QAEzC,OAAO,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;YAC7C,MAAM;YACN,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;SAC9B,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACK,IAAI,CACV,MAAyC,EACzC,MAAc;QAEd,MAAM,OAAO,GAAG,MAAM,CAAC,WAAW,IAAI,EAAE,CAAC;QAEzC,IAAI,OAAO,KAAK,EAAE,IAAI,wBAAwB,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;YAC3D,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;;OAKG;IACK,OAAO,CAAC,MAAyC;QACvD,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;QAE9B,IAAI,MAAM,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;YACrC,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;QAClD,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-forward-target.d.ts

@@ -0,0 +1,24 @@
+import type { SimElbV2 } from "../sim-elbv2.js";
+import type { SimElbV2TargetGroup } from "../target-group/sim-elbv2-target-group.js";
+import type { SimElbV2MatchedAction } from "./sim-elbv2-rule-evaluation.js";
+/**
+ * Works out which target group a `forward` action sends a request to.
+ *
+ * The action is stored when the listener or rule is written and performed here,
+ * and the two are not the same thing: a forward this simulation cannot carry
+ * out is one that was accepted and cannot serve. That is refused when the
+ * request arrives rather than answered with something else, because a load
+ * balancer that quietly sends a request somewhere its configuration did not say
+ * is worse than one that says it cannot. What the group holds is not one of
+ * those refusals: both simulated target types answer a request, in their own
+ * ways.
+ */
+export declare class SimElbV2ForwardTarget {
+    private readonly elbV2;
+    constructor(elbV2: SimElbV2);
+    /**
+     * The target group a matched forward action sends a request to.
+     */
+    resolve(matched: SimElbV2MatchedAction): SimElbV2TargetGroup;
+}
+//# sourceMappingURL=sim-elbv2-forward-target.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-forward-target.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-forward-target.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAE5E;;;;;;;;;;;GAWG;AACH,qBAAa,qBAAqB;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAAlC,YAA6B,KAAK,EAAE,QAAQ,EAAI;IAEhD;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,qBAAqB,GAAG,mBAAmB,CA2B3D;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-forward-target.js

@@ -0,0 +1,41 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { SimElbV2UnsimulatedInputException } from "../error/sim-elbv2.error.js";
+/**
+ * Works out which target group a `forward` action sends a request to.
+ *
+ * The action is stored when the listener or rule is written and performed here,
+ * and the two are not the same thing: a forward this simulation cannot carry
+ * out is one that was accepted and cannot serve. That is refused when the
+ * request arrives rather than answered with something else, because a load
+ * balancer that quietly sends a request somewhere its configuration did not say
+ * is worse than one that says it cannot. What the group holds is not one of
+ * those refusals: both simulated target types answer a request, in their own
+ * ways.
+ */
+export class SimElbV2ForwardTarget {
+    elbV2;
+    constructor(elbV2) {
+        this.elbV2 = elbV2;
+    }
+    /**
+     * The target group a matched forward action sends a request to.
+     */
+    resolve(matched) {
+        const { action, source } = matched;
+        if (action.targetGroupArns.length > 1) {
+            throw new SimElbV2UnsimulatedInputException(`${source} forwards to ` +
+                `${String(action.targetGroupArns.length)} target groups. Weighted ` +
+                `forwarding is not simulated, so which of them takes a request is ` +
+                `not something this can answer.`);
+        }
+        const [targetGroupArn] = action.targetGroupArns;
+        // A forward action names a target group that exists when it is written,
+        // and one anything forwards to cannot be deleted.
+        assertDefined(targetGroupArn, `${source} forwards to no target group`);
+        const targetGroup = this.elbV2.findTargetGroupByArn(targetGroupArn);
+        assertDefined(targetGroup, `${source} forwards to the target group ${targetGroupArn}, which is ` +
+            `not there`);
+        return targetGroup;
+    }
+}
+//# sourceMappingURL=sim-elbv2-forward-target.js.map

package/dist/service/elbv2/serve/sim-elbv2-forward-target.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-forward-target.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-forward-target.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,EAAE,iCAAiC,EAAE,MAAM,6BAA6B,CAAC;AAKhF;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,qBAAqB;IACH,KAAK;IAAlC,YAA6B,KAAe;qBAAf,KAAK;IAAa,CAAC;IAEhD;;OAEG;IACH,OAAO,CAAC,OAA8B;QACpC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;QAEnC,IAAI,MAAM,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtC,MAAM,IAAI,iCAAiC,CACzC,GAAG,MAAM,eAAe;gBACtB,GAAG,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,CAAC,2BAA2B;gBACnE,mEAAmE;gBACnE,gCAAgC,CACnC,CAAC;QACJ,CAAC;QAED,MAAM,CAAC,cAAc,CAAC,GAAG,MAAM,CAAC,eAAe,CAAC;QAEhD,wEAAwE;QACxE,kDAAkD;QAClD,aAAa,CAAC,cAAc,EAAE,GAAG,MAAM,8BAA8B,CAAC,CAAC;QAEvE,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAC;QAEpE,aAAa,CACX,WAAW,EACX,GAAG,MAAM,iCAAiC,cAAc,aAAa;YACnE,WAAW,CACd,CAAC;QAEF,OAAO,WAAW,CAAC;IACrB,CAAC;CACF"}

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

@@ -0,0 +1,44 @@
+import type { SimClock } from "../../../util/clock/sim-clock.js";
+import type { SimElbV2Listener } from "../listener/sim-elbv2-listener.js";
+interface SimElbV2ForwardedRequestProperties {
+    /** Clock the forwarded trace id is stamped with. */
+    readonly clock: SimClock;
+}
+interface SimElbV2ForwardedRequestInput {
+    readonly request: Request;
+    readonly listener: SimElbV2Listener;
+}
+/**
+ * Builds the request a load balancer forwards to a container target.
+ *
+ * A Lambda target gets an event, and a container gets the request itself, so
+ * this is the container's half of what the event builder does: the same host
+ * name, the same trace id and the same forwarding headers, applied to a request
+ * rather than gathered into a payload. Keeping the rules in
+ * `SimElbV2RequestParts` for both is what stops a container and a function
+ * behind the same listener disagreeing about what the client asked for.
+ *
+ * The URL is rewritten to the AWS-facing one, so a container reading
+ * `request.url` sees the name the client asked for rather than the localhost
+ * one a served request arrived at, and sees the listener's scheme and port
+ * rather than the local server's.
+ */
+export declare class SimElbV2ForwardedRequest {
+    private readonly requestParts;
+    private readonly clock;
+    constructor(properties: SimElbV2ForwardedRequestProperties);
+    /**
+     * Build the request one container target is handed.
+     */
+    build(input: SimElbV2ForwardedRequestInput): Request;
+    /**
+     * The URL the forwarded request carries.
+     *
+     * A port the listener's own scheme is served on drops out of its own accord,
+     * as it does in any URL, so a listener on 80 forwards a request to
+     * `http://name/path` rather than to `http://name:80/path`.
+     */
+    private urlFor;
+}
+export {};
+//# sourceMappingURL=sim-elbv2-forwarded-request.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-forwarded-request.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-forwarded-request.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAG1E,UAAU,kCAAkC;IAC1C,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;CAC1B;AAED,UAAU,6BAA6B;IACrC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;CACrC;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA8B;IAC3D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;IAEjC,YAAY,UAAU,EAAE,kCAAkC,EAEzD;IAED;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,6BAA6B,GAAG,OAAO,CAgBnD;IAED;;;;;;OAMG;IACH,OAAO,CAAC,MAAM;CAYf"}

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

@@ -0,0 +1,61 @@
+import { simAwsProxiedSourceIp, simAwsProxiedTraceId, } from "../../../serve/http/sim-aws-proxied-connection.js";
+import { simAwsRequestHostname } from "../../../serve/http/url/sim-aws-request-hostname.js";
+import { SimElbV2RequestParts } from "./sim-elbv2-request-parts.js";
+/**
+ * Builds the request a load balancer forwards to a container target.
+ *
+ * A Lambda target gets an event, and a container gets the request itself, so
+ * this is the container's half of what the event builder does: the same host
+ * name, the same trace id and the same forwarding headers, applied to a request
+ * rather than gathered into a payload. Keeping the rules in
+ * `SimElbV2RequestParts` for both is what stops a container and a function
+ * behind the same listener disagreeing about what the client asked for.
+ *
+ * The URL is rewritten to the AWS-facing one, so a container reading
+ * `request.url` sees the name the client asked for rather than the localhost
+ * one a served request arrived at, and sees the listener's scheme and port
+ * rather than the local server's.
+ */
+export class SimElbV2ForwardedRequest {
+    requestParts = new SimElbV2RequestParts();
+    clock;
+    constructor(properties) {
+        this.clock = properties.clock;
+    }
+    /**
+     * Build the request one container target is handed.
+     */
+    build(input) {
+        const { request, listener } = input;
+        const forwarded = new Request(this.urlFor(input), request);
+        const headers = this.requestParts.headers({
+            request,
+            port: listener.port,
+            protocol: listener.protocol,
+            traceId: simAwsProxiedTraceId(this.clock.now()),
+            sourceIp: simAwsProxiedSourceIp,
+        });
+        for (const [name, value] of Object.entries(headers)) {
+            forwarded.headers.set(name, value);
+        }
+        return forwarded;
+    }
+    /**
+     * The URL the forwarded request carries.
+     *
+     * A port the listener's own scheme is served on drops out of its own accord,
+     * as it does in any URL, so a listener on 80 forwards a request to
+     * `http://name/path` rather than to `http://name:80/path`.
+     */
+    urlFor(input) {
+        const { request, listener } = input;
+        const scheme = listener.protocol.toLowerCase();
+        const forwarded = new URL(`${scheme}://${simAwsRequestHostname(request)}/`);
+        const asked = new URL(request.url);
+        forwarded.port = String(listener.port);
+        forwarded.pathname = asked.pathname;
+        forwarded.search = asked.search;
+        return forwarded.href;
+    }
+}
+//# sourceMappingURL=sim-elbv2-forwarded-request.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-forwarded-request.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-forwarded-request.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAG5F,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAYpE;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,wBAAwB;IAClB,YAAY,GAAG,IAAI,oBAAoB,EAAE,CAAC;IAC1C,KAAK,CAAW;IAEjC,YAAY,UAA8C;QACxD,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAoC;QACxC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;QACpC,MAAM,SAAS,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC;QAC3D,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;YACxC,OAAO;YACP,IAAI,EAAE,QAAQ,CAAC,IAAI;YACnB,QAAQ,EAAE,QAAQ,CAAC,QAAQ;YAC3B,OAAO,EAAE,oBAAoB,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;YAC/C,QAAQ,EAAE,qBAAqB;SAChC,CAAC,CAAC;QAEH,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YACpD,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACrC,CAAC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;;;;;OAMG;IACK,MAAM,CAAC,KAAoC;QACjD,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;QACpC,MAAM,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;QAC/C,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,GAAG,MAAM,MAAM,qBAAqB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC5E,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAEnC,SAAS,CAAC,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACvC,SAAS,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QACpC,SAAS,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QAEhC,OAAO,SAAS,CAAC,IAAI,CAAC;IACxB,CAAC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-invoke-authorizer.d.ts

@@ -0,0 +1,49 @@
+import type { SimIamAuthorizationDecision, SimIamInterServiceAuthZ } from "../../iam/authorize/sim-iam-inter-service-auth-z.js";
+import type { SimLambdaFunction } from "../../lambda/function/sim-lambda-function.js";
+import type { SimElbV2TargetGroup } from "../target-group/sim-elbv2-target-group.js";
+/**
+ * The service principal Elastic Load Balancing invokes a Lambda function as.
+ */
+export declare const simElbV2ServicePrincipal = "elasticloadbalancing.amazonaws.com";
+interface SimElbV2InvokeAuthorizerProperties {
+    readonly iam: SimIamInterServiceAuthZ;
+}
+interface SimElbV2InvokeAuthorizationInput {
+    readonly simFunction: SimLambdaFunction;
+    readonly targetGroup: SimElbV2TargetGroup;
+    readonly accountId: string;
+}
+/**
+ * Decides whether a load balancer may invoke the function in a target group.
+ *
+ * A Lambda target registered through CloudFormation, the CLI or an SDK does not
+ * serve anything until the function's resource policy allows
+ * `elasticloadbalancing.amazonaws.com` to invoke it. That grant is the one
+ * thing standing between a target group that looks configured and one that
+ * answers, and forgetting it is a common way to get a load balancer that
+ * returns nothing but errors.
+ *
+ * Whether a service may invoke a function is Lambda's own rule, so the decision
+ * is made there. What this adds is the part only ELB knows: which target group
+ * is calling.
+ *
+ * The answer is a decision rather than a thrown error, because a refusal is an
+ * ordinary HTTP outcome: the load balancer answers 502 the way real ELB does,
+ * with nothing to propagate to a caller in process.
+ */
+export declare class SimElbV2InvokeAuthorizer {
+    private readonly lambdaAuthorizer;
+    constructor(properties: SimElbV2InvokeAuthorizerProperties);
+    /**
+     * Evaluate `lambda:InvokeFunction` for the load balancer against the
+     * function.
+     *
+     * The target group is supplied as `AWS:SourceArn` and its Account as
+     * `AWS:SourceAccount`, which is what the `add-permission` call in the ELB
+     * documentation names, so a permission granted for one target group does not
+     * open another.
+     */
+    authorize(input: SimElbV2InvokeAuthorizationInput): SimIamAuthorizationDecision;
+}
+export {};
+//# sourceMappingURL=sim-elbv2-invoke-authorizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-invoke-authorizer.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-invoke-authorizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,uBAAuB,EACxB,MAAM,qDAAqD,CAAC;AAE7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AACtF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAErF;;GAEG;AACH,eAAO,MAAM,wBAAwB,uCAAuC,CAAC;AAE7E,UAAU,kCAAkC;IAC1C,QAAQ,CAAC,GAAG,EAAE,uBAAuB,CAAC;CACvC;AAED,UAAU,gCAAgC;IACxC,QAAQ,CAAC,WAAW,EAAE,iBAAiB,CAAC;IACxC,QAAQ,CAAC,WAAW,EAAE,mBAAmB,CAAC;IAC1C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmC;IAEpE,YAAY,UAAU,EAAE,kCAAkC,EAIzD;IAED;;;;;;;;OAQG;IACH,SAAS,CACP,KAAK,EAAE,gCAAgC,GACtC,2BAA2B,CAO7B;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-invoke-authorizer.js

@@ -0,0 +1,49 @@
+import { SimLambdaServiceInvokeAuthorizer } from "../../lambda/command/authorize/sim-lambda-service-invoke-authorizer.js";
+/**
+ * The service principal Elastic Load Balancing invokes a Lambda function as.
+ */
+export const simElbV2ServicePrincipal = "elasticloadbalancing.amazonaws.com";
+/**
+ * Decides whether a load balancer may invoke the function in a target group.
+ *
+ * A Lambda target registered through CloudFormation, the CLI or an SDK does not
+ * serve anything until the function's resource policy allows
+ * `elasticloadbalancing.amazonaws.com` to invoke it. That grant is the one
+ * thing standing between a target group that looks configured and one that
+ * answers, and forgetting it is a common way to get a load balancer that
+ * returns nothing but errors.
+ *
+ * Whether a service may invoke a function is Lambda's own rule, so the decision
+ * is made there. What this adds is the part only ELB knows: which target group
+ * is calling.
+ *
+ * The answer is a decision rather than a thrown error, because a refusal is an
+ * ordinary HTTP outcome: the load balancer answers 502 the way real ELB does,
+ * with nothing to propagate to a caller in process.
+ */
+export class SimElbV2InvokeAuthorizer {
+    lambdaAuthorizer;
+    constructor(properties) {
+        this.lambdaAuthorizer = new SimLambdaServiceInvokeAuthorizer({
+            iam: properties.iam,
+        });
+    }
+    /**
+     * Evaluate `lambda:InvokeFunction` for the load balancer against the
+     * function.
+     *
+     * The target group is supplied as `AWS:SourceArn` and its Account as
+     * `AWS:SourceAccount`, which is what the `add-permission` call in the ELB
+     * documentation names, so a permission granted for one target group does not
+     * open another.
+     */
+    authorize(input) {
+        return this.lambdaAuthorizer.authorize({
+            simFunction: input.simFunction,
+            servicePrincipal: simElbV2ServicePrincipal,
+            sourceArn: input.targetGroup.arn,
+            sourceAccount: input.accountId,
+        });
+    }
+}
+//# sourceMappingURL=sim-elbv2-invoke-authorizer.js.map

package/dist/service/elbv2/serve/sim-elbv2-invoke-authorizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-invoke-authorizer.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-invoke-authorizer.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,gCAAgC,EAAE,MAAM,wEAAwE,CAAC;AAI1H;;GAEG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,oCAAoC,CAAC;AAY7E;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,wBAAwB;IAClB,gBAAgB,CAAmC;IAEpE,YAAY,UAA8C;QACxD,IAAI,CAAC,gBAAgB,GAAG,IAAI,gCAAgC,CAAC;YAC3D,GAAG,EAAE,UAAU,CAAC,GAAG;SACpB,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACH,SAAS,CACP,KAAuC;QAEvC,OAAO,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC;YACrC,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,gBAAgB,EAAE,wBAAwB;YAC1C,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,GAAG;YAChC,aAAa,EAAE,KAAK,CAAC,SAAS;SAC/B,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-lambda-target-invocation.d.ts

@@ -0,0 +1,37 @@
+import type { SimClock } from "../../../util/clock/sim-clock.js";
+import type { SimElbV2Router } from "./sim-elbv2-router.js";
+import type { SimElbV2TargetInvocation, SimElbV2TargetInvocationInput } from "./sim-elbv2-target-invocation.js";
+interface SimElbV2LambdaTargetInvocationProperties {
+    readonly router: SimElbV2Router;
+    /** Clock the invocation event is stamped with. */
+    readonly clock: SimClock;
+}
+/**
+ * Invokes the Lambda function registered in a target group, and turns what it
+ * returns into the HTTP response.
+ *
+ * A target group with nothing in it is a 503, because there is no target to
+ * send the request to. Everything that goes wrong once there is one is a 502:
+ * a function that is not there, one the load balancer may not invoke, one that
+ * threw, and one whose result is not a response. That is what real ELB does
+ * too, and it is why the load balancer's own logs are the only place the
+ * difference between them shows.
+ */
+export declare class SimElbV2LambdaTargetInvocation implements SimElbV2TargetInvocation {
+    private readonly router;
+    private readonly eventBuilder;
+    private readonly responseBuilder;
+    private readonly errorResponse;
+    constructor(properties: SimElbV2LambdaTargetInvocationProperties);
+    /**
+     * Invoke the target group's function for one request.
+     */
+    invoke(input: SimElbV2TargetInvocationInput): Promise<Response>;
+    /**
+     * Whether the load balancer lacks permission to invoke the function.
+     */
+    private mayNotInvoke;
+    private run;
+}
+export {};
+//# sourceMappingURL=sim-elbv2-lambda-target-invocation.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-lambda-target-invocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-lambda-target-invocation.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-lambda-target-invocation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAMjE,OAAO,KAAK,EAEV,cAAc,EACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EACV,wBAAwB,EACxB,6BAA6B,EAC9B,MAAM,kCAAkC,CAAC;AAO1C,UAAU,wCAAwC;IAChD,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,kDAAkD;IAClD,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;CAC1B;AAED;;;;;;;;;;GAUG;AACH,qBAAa,8BAA+B,YAAW,wBAAwB;IAC7E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAuB;IACpD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAiC;IACjE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA+B;IAE7D,YAAY,UAAU,EAAE,wCAAwC,EAK/D;IAED;;OAEG;IACG,MAAM,CAAC,KAAK,EAAE,6BAA6B,GAAG,OAAO,CAAC,QAAQ,CAAC,CAcpE;IAED;;OAEG;IACH,OAAO,CAAC,YAAY;YAWN,GAAG;CA6BlB"}

package/dist/service/elbv2/serve/sim-elbv2-lambda-target-invocation.js

@@ -0,0 +1,79 @@
+import { SimElbV2ErrorResponse } from "./sim-elbv2-error-response.js";
+import { SimElbV2EventBuilder } from "./sim-elbv2-event-builder.js";
+import { SimElbV2InvokeAuthorizer } from "./sim-elbv2-invoke-authorizer.js";
+import { SimElbV2ResponseBuilder } from "./sim-elbv2-response-builder.js";
+/**
+ * The largest request body real ELB sends to a Lambda target.
+ */
+const maximumRequestBytes = 1024 * 1024;
+/**
+ * Invokes the Lambda function registered in a target group, and turns what it
+ * returns into the HTTP response.
+ *
+ * A target group with nothing in it is a 503, because there is no target to
+ * send the request to. Everything that goes wrong once there is one is a 502:
+ * a function that is not there, one the load balancer may not invoke, one that
+ * threw, and one whose result is not a response. That is what real ELB does
+ * too, and it is why the load balancer's own logs are the only place the
+ * difference between them shows.
+ */
+export class SimElbV2LambdaTargetInvocation {
+    router;
+    eventBuilder;
+    responseBuilder = new SimElbV2ResponseBuilder();
+    errorResponse = new SimElbV2ErrorResponse();
+    constructor(properties) {
+        this.router = properties.router;
+        this.eventBuilder = new SimElbV2EventBuilder({
+            clock: properties.clock,
+        });
+    }
+    /**
+     * Invoke the target group's function for one request.
+     */
+    async invoke(input) {
+        const { targetGroup } = input;
+        if (targetGroup.registeredTargets.length === 0) {
+            return this.errorResponse.serviceUnavailable();
+        }
+        const target = this.router.functionFor(targetGroup);
+        if (target === undefined || this.mayNotInvoke(targetGroup, target)) {
+            return this.errorResponse.badGateway();
+        }
+        return await this.run(input, target);
+    }
+    /**
+     * Whether the load balancer lacks permission to invoke the function.
+     */
+    mayNotInvoke(targetGroup, target) {
+        return new SimElbV2InvokeAuthorizer({ iam: target.iam }).authorize({
+            simFunction: target.simFunction,
+            targetGroup,
+            accountId: targetGroup.accountRegionScope.accountId,
+        }).isDenied;
+    }
+    async run(input, target) {
+        const { listener, targetGroup, request } = input;
+        try {
+            const bytes = new Uint8Array(await request.arrayBuffer());
+            if (bytes.length > maximumRequestBytes) {
+                return this.errorResponse.payloadTooLarge();
+            }
+            const event = this.eventBuilder.build({
+                request,
+                bytes,
+                targetGroupArn: targetGroup.arn,
+                port: listener.port,
+                protocol: listener.protocol,
+            });
+            return this.responseBuilder.build(await target.simFunction.invoke(event));
+        }
+        catch {
+            // A handler that threw is a 502 with the error only in the function's
+            // own logs, as it is on real ELB. Reading the request body can fail the
+            // same way, so building the event is inside this too.
+            return this.errorResponse.badGateway();
+        }
+    }
+}
+//# sourceMappingURL=sim-elbv2-lambda-target-invocation.js.map

package/dist/service/elbv2/serve/sim-elbv2-lambda-target-invocation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-lambda-target-invocation.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-lambda-target-invocation.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAU1E;;GAEG;AACH,MAAM,mBAAmB,GAAG,IAAI,GAAG,IAAI,CAAC;AAQxC;;;;;;;;;;GAUG;AACH,MAAM,OAAO,8BAA8B;IACxB,MAAM,CAAiB;IACvB,YAAY,CAAuB;IACnC,eAAe,GAAG,IAAI,uBAAuB,EAAE,CAAC;IAChD,aAAa,GAAG,IAAI,qBAAqB,EAAE,CAAC;IAE7D,YAAY,UAAoD;QAC9D,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;QAChC,IAAI,CAAC,YAAY,GAAG,IAAI,oBAAoB,CAAC;YAC3C,KAAK,EAAE,UAAU,CAAC,KAAK;SACxB,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,KAAoC;QAC/C,MAAM,EAAE,WAAW,EAAE,GAAG,KAAK,CAAC;QAE9B,IAAI,WAAW,CAAC,iBAAiB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/C,OAAO,IAAI,CAAC,aAAa,CAAC,kBAAkB,EAAE,CAAC;QACjD,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QAEpD,IAAI,MAAM,KAAK,SAAS,IAAI,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,MAAM,CAAC,EAAE,CAAC;YACnE,OAAO,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,CAAC;QACzC,CAAC;QAED,OAAO,MAAM,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACvC,CAAC;IAED;;OAEG;IACK,YAAY,CAClB,WAAgC,EAChC,MAA8B;QAE9B,OAAO,IAAI,wBAAwB,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,SAAS,CAAC;YACjE,WAAW,EAAE,MAAM,CAAC,WAAW;YAC/B,WAAW;YACX,SAAS,EAAE,WAAW,CAAC,kBAAkB,CAAC,SAAS;SACpD,CAAC,CAAC,QAAQ,CAAC;IACd,CAAC;IAEO,KAAK,CAAC,GAAG,CACf,KAAoC,EACpC,MAA8B;QAE9B,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC;QAEjD,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;YAE1D,IAAI,KAAK,CAAC,MAAM,GAAG,mBAAmB,EAAE,CAAC;gBACvC,OAAO,IAAI,CAAC,aAAa,CAAC,eAAe,EAAE,CAAC;YAC9C,CAAC;YAED,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;gBACpC,OAAO;gBACP,KAAK;gBACL,cAAc,EAAE,WAAW,CAAC,GAAG;gBAC/B,IAAI,EAAE,QAAQ,CAAC,IAAI;gBACnB,QAAQ,EAAE,QAAQ,CAAC,QAAQ;aAC5B,CAAC,CAAC;YAEH,OAAO,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5E,CAAC;QAAC,MAAM,CAAC;YACP,sEAAsE;YACtE,wEAAwE;YACxE,sDAAsD;YACtD,OAAO,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,CAAC;QACzC,CAAC;IACH,CAAC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-lambda-target.factory.d.ts

@@ -0,0 +1,52 @@
+import { AsyncMappedFactory } from "@kensio/part-factory";
+import type { SimAws } from "../../aws/sim-aws.js";
+import type { SimElbV2LoadBalancer } from "../load-balancer/sim-elbv2-load-balancer.js";
+import type { SimElbV2Event } from "./sim-elbv2-event.type.js";
+/**
+ * The load balancer, target group and function this builds.
+ *
+ * The names are fixed rather than asked for, so a test asserting on an ARN or
+ * a DNS name has one value to write down.
+ */
+export declare const simElbV2LambdaTargetNames: {
+    readonly loadBalancer: "shop-alb";
+    readonly targetGroup: "checkout-tg";
+    readonly function: "checkout";
+    /** The statement id the invoke permission is granted under. */
+    readonly invokeStatement: "elb-invoke";
+};
+/**
+ * What a test asks for when it wants a load balancer that serves something.
+ */
+export interface SimElbV2LambdaTargetInput {
+    /** The function code the load balancer hands its requests to. */
+    readonly handler: (event: SimElbV2Event) => unknown;
+    /** The port the listener answers on. */
+    readonly listenerPort: number;
+}
+/**
+ * Creates a load balancer that forwards every request to a Lambda function,
+ * through the ordinary commands.
+ *
+ * Five commands and a function stand between a test and a request a load
+ * balancer can answer, and a test about answering one is about none of them.
+ * Tests about the commands themselves send them one at a time instead.
+ *
+ * ```typescript
+ * const loadBalancer = await simElbV2LambdaTargetFactory.make(
+ *   { handler: () => ({ statusCode: 200, body: "hello" }) },
+ *   simAws,
+ * );
+ * ```
+ *
+ * What comes back is a load balancer that serves: the function is registered
+ * and it grants the load balancer the invoke action. A test about one of those
+ * missing takes it away again, which is also what a working stack losing it
+ * looks like.
+ *
+ * Everything is created in the default Account and Region of the simulated AWS
+ * it is given, because real ELB requires a Lambda target to be in the same
+ * Account and Region as its target group.
+ */
+export declare const simElbV2LambdaTargetFactory: AsyncMappedFactory<SimElbV2LambdaTargetInput, SimElbV2LoadBalancer, SimAws>;
+//# sourceMappingURL=sim-elbv2-lambda-target.factory.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-lambda-target.factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-lambda-target.factory.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-lambda-target.factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6CAA6C,CAAC;AAKxF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAO/D;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;aACpC,YAAY,EAAE,UAAU;aACxB,WAAW,EAAE,aAAa;aAC1B,QAAQ,EAAE,UAAU;IACpB,+DAA+D;aAC/D,eAAe;CACP,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,OAAO,CAAC;IACpD,wCAAwC;IACxC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,2BAA2B,6EAqCvC,CAAC"}