@kensio/yulin 1.13.0 → 1.14.0

package/dist/service/ecr/sim-ecr.js

@@ -0,0 +1,66 @@
+import { simAwsAccountRegionScopeFactory } from "../aws/sim-aws-account-region-scope.factory.js";
+import { SimEcrCfnResourceFactory } from "./cfn/sim-ecr-cfn-resource-factory.js";
+import { SimEcrRegistry } from "./registry/sim-ecr-registry.js";
+import { SimEcrRepositoryAddress } from "./repository/sim-ecr-repository-address.js";
+import { SimEcrRepositoryStore } from "./repository/sim-ecr-repository-store.js";
+/**
+ * Simulated ECR. Holds repositories, each holding images by tag.
+ *
+ * There are no SDK commands here, and that is deliberate. What this service is
+ * for is saying what an image actually is, and real ECR has no operation that
+ * could say it: `PutImage` takes a manifest for layers pushed over the Docker
+ * registry protocol, none of which exists in this process. So registering a
+ * handler as an image is a Yulin-native operation, named so it cannot be
+ * mistaken for a simulated `PutImage`.
+ *
+ * Repositories are scoped to an account and region, as they are on real AWS:
+ * a repository ARN names the region, and the registry host in an image URI
+ * carries both the account and the region.
+ */
+export class SimEcr {
+    repositories;
+    cfnFactory = new SimEcrCfnResourceFactory({ ecr: this });
+    constructor(properties = {}) {
+        const { accountRegionScope = simAwsAccountRegionScopeFactory.make(), registry = new SimEcrRegistry(), } = properties;
+        this.repositories = new SimEcrRepositoryStore({
+            address: new SimEcrRepositoryAddress(accountRegionScope),
+            registry,
+        });
+    }
+    /**
+     * The repository of this name, made if this is the first mention of it.
+     *
+     * Naming a repository is what creates it. A repository holds no state of its
+     * own beyond the images registered in it, so there is nothing to declare
+     * before registering one, and a test can name the repository its templates
+     * already point at.
+     */
+    repository(repositoryName) {
+        return this.repositories.repository(repositoryName);
+    }
+    /**
+     * Whether a repository of this name has been made.
+     */
+    hasRepository(repositoryName) {
+        return this.repositories.has(repositoryName);
+    }
+    /**
+     * Remove a repository, and the simulated images it holds with it.
+     */
+    deleteRepository(repositoryName) {
+        this.repositories.delete(repositoryName);
+    }
+    /**
+     * Every repository this simulated ECR holds.
+     */
+    allRepositories() {
+        return this.repositories.all();
+    }
+    /**
+     * Get this service's CloudFormation Resource factory.
+     */
+    cfnResourceFactory() {
+        return this.cfnFactory;
+    }
+}
+//# sourceMappingURL=sim-ecr.js.map

package/dist/service/ecr/sim-ecr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecr.js","sourceRoot":"","sources":["../../../src/service/ecr/sim-ecr.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,+BAA+B,EAAE,MAAM,gDAAgD,CAAC;AAEjG,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,uBAAuB,EAAE,MAAM,4CAA4C,CAAC;AAErF,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AAOjF;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,MAAM;IACA,YAAY,CAAwB;IACpC,UAAU,GAAG,IAAI,wBAAwB,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;IAE1E,YAAY,UAAU,GAAqB,EAAE;QAC3C,MAAM,EACJ,kBAAkB,GAAG,+BAA+B,CAAC,IAAI,EAAE,EAC3D,QAAQ,GAAG,IAAI,cAAc,EAAE,GAChC,GAAG,UAAU,CAAC;QAEf,IAAI,CAAC,YAAY,GAAG,IAAI,qBAAqB,CAAC;YAC5C,OAAO,EAAE,IAAI,uBAAuB,CAAC,kBAAkB,CAAC;YACxD,QAAQ;SACT,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACH,UAAU,CAAC,cAAsB;QAC/B,OAAO,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;IACtD,CAAC;IAED;;OAEG;IACH,aAAa,CAAC,cAAsB;QAClC,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAC/C,CAAC;IAED;;OAEG;IACH,gBAAgB,CAAC,cAAsB;QACrC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,eAAe;QACb,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,kBAAkB;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;CACF"}

package/dist/service/ecs/bind/sim-ecs-bound-container-work.d.ts

@@ -0,0 +1,22 @@
+import { SimEcsBoundQueueConsumer } from "./sim-ecs-bound-queue-consumer.js";
+import type { SimEcsContainerBinding, SimEcsContainerHttpHandler, SimEcsContainerRunHandler } from "./sim-ecs-container-binding.type.js";
+/**
+ * What a bound container actually does, read once as the binding is made.
+ *
+ * A binding says one of three things. A `run` handler is a job container that
+ * does its work and exits. A `consumes` declaration is a worker container,
+ * whose real image would sit in an endless receive-handle-delete loop; Yulin
+ * runs that loop and the binding supplies its body, because an endless loop in
+ * a single Node.js process would never yield to the test running it. An `http`
+ * handler is a service container behind a load balancer, called once per
+ * request that reaches it.
+ */
+export declare class SimEcsBoundContainerWork {
+    readonly run: SimEcsContainerRunHandler | undefined;
+    readonly consumes: SimEcsBoundQueueConsumer | undefined;
+    readonly serves: SimEcsContainerHttpHandler | undefined;
+    constructor(binding: SimEcsContainerBinding);
+    private static httpHandlerOf;
+    private static runHandlerOf;
+}
+//# sourceMappingURL=sim-ecs-bound-container-work.d.ts.map

package/dist/service/ecs/bind/sim-ecs-bound-container-work.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-bound-container-work.d.ts","sourceRoot":"","sources":["../../../../src/service/ecs/bind/sim-ecs-bound-container-work.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,KAAK,EACV,sBAAsB,EACtB,0BAA0B,EAC1B,yBAAyB,EAC1B,MAAM,qCAAqC,CAAC;AAE7C;;;;;;;;;;GAUG;AACH,qBAAa,wBAAwB;IACnC,SAAgB,GAAG,EAAE,yBAAyB,GAAG,SAAS,CAAC;IAC3D,SAAgB,QAAQ,EAAE,wBAAwB,GAAG,SAAS,CAAC;IAC/D,SAAgB,MAAM,EAAE,0BAA0B,GAAG,SAAS,CAAC;IAE/D,YAAY,OAAO,EAAE,sBAAsB,EAc1C;IAED,OAAO,CAAC,MAAM,CAAC,aAAa;IAa5B,OAAO,CAAC,MAAM,CAAC,YAAY;CAa5B"}

package/dist/service/ecs/bind/sim-ecs-bound-container-work.js

@@ -0,0 +1,44 @@
+import { SimEcsBoundQueueConsumer } from "./sim-ecs-bound-queue-consumer.js";
+/**
+ * What a bound container actually does, read once as the binding is made.
+ *
+ * A binding says one of three things. A `run` handler is a job container that
+ * does its work and exits. A `consumes` declaration is a worker container,
+ * whose real image would sit in an endless receive-handle-delete loop; Yulin
+ * runs that loop and the binding supplies its body, because an endless loop in
+ * a single Node.js process would never yield to the test running it. An `http`
+ * handler is a service container behind a load balancer, called once per
+ * request that reaches it.
+ */
+export class SimEcsBoundContainerWork {
+    run;
+    consumes;
+    serves;
+    constructor(binding) {
+        if (binding.consumes !== undefined) {
+            this.consumes = new SimEcsBoundQueueConsumer(binding.consumes);
+            return;
+        }
+        if (binding.http !== undefined) {
+            this.serves = SimEcsBoundContainerWork.httpHandlerOf(binding.http);
+            return;
+        }
+        this.run = SimEcsBoundContainerWork.runHandlerOf(binding);
+    }
+    static httpHandlerOf(handler) {
+        if (typeof handler !== "function") {
+            throw new TypeError("Invalid sim ECS container binding: a serving container needs an " +
+                "http handler, which is what it answers a request with.");
+        }
+        return handler;
+    }
+    static runHandlerOf(binding) {
+        if (typeof binding.run !== "function") {
+            throw new TypeError("Invalid sim ECS container binding: a binding needs a run handler, " +
+                "which is the function the container runs, or a consumes " +
+                "declaration naming the queue the container reads.");
+        }
+        return binding.run;
+    }
+}
+//# sourceMappingURL=sim-ecs-bound-container-work.js.map

package/dist/service/ecs/bind/sim-ecs-bound-container-work.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-bound-container-work.js","sourceRoot":"","sources":["../../../../src/service/ecs/bind/sim-ecs-bound-container-work.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAO7E;;;;;;;;;;GAUG;AACH,MAAM,OAAO,wBAAwB;IACnB,GAAG,CAAwC;IAC3C,QAAQ,CAAuC;IAC/C,MAAM,CAAyC;IAE/D,YAAY,OAA+B;QACzC,IAAI,OAAO,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;YACnC,IAAI,CAAC,QAAQ,GAAG,IAAI,wBAAwB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;YAE/D,OAAO;QACT,CAAC;QAED,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC/B,IAAI,CAAC,MAAM,GAAG,wBAAwB,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAEnE,OAAO;QACT,CAAC;QAED,IAAI,CAAC,GAAG,GAAG,wBAAwB,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IAC5D,CAAC;IAEO,MAAM,CAAC,aAAa,CAC1B,OAAmC;QAEnC,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE,CAAC;YAClC,MAAM,IAAI,SAAS,CACjB,kEAAkE;gBAChE,wDAAwD,CAC3D,CAAC;QACJ,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,MAAM,CAAC,YAAY,CACzB,OAA+B;QAE/B,IAAI,OAAO,OAAO,CAAC,GAAG,KAAK,UAAU,EAAE,CAAC;YACtC,MAAM,IAAI,SAAS,CACjB,oEAAoE;gBAClE,0DAA0D;gBAC1D,mDAAmD,CACtD,CAAC;QACJ,CAAC;QAED,OAAO,OAAO,CAAC,GAAG,CAAC;IACrB,CAAC;CACF"}

package/dist/service/ecs/bind/sim-ecs-bound-container.d.ts

@@ -0,0 +1,65 @@
+import type { SimEcsContainerDefinition } from "../task-definition/container/sim-ecs-container-definition.js";
+import type { SimEcsBoundQueueConsumer } from "./sim-ecs-bound-queue-consumer.js";
+import type { SimEcsContainerBinding, SimEcsContainerHttpHandler } from "./sim-ecs-container-binding.type.js";
+/**
+ * One executable binding, read once and ready to be matched against.
+ *
+ * A binding is checked as it is made rather than when a task runs it. Binding
+ * is something a test does while setting up, so a binding that could never
+ * match anything is worth refusing there, where the mistake is.
+ *
+ * The image repository is matched by the same target the CloudFormation
+ * bindings use, so a repository means the same thing to a container as it does
+ * to a container image Lambda function: the registry host and the repository
+ * name have to match, and the tag is ignored on both sides.
+ */
+export declare class SimEcsBoundContainer {
+    readonly family: string | undefined;
+    readonly containerName: string | undefined;
+    readonly imageRepository: string | undefined;
+    private readonly work;
+    private readonly repositoryTarget;
+    constructor(binding: SimEcsContainerBinding);
+    private static targetFor;
+    /**
+     * The queue this binding consumes, where it consumes one.
+     *
+     * A consuming container is the one thing a service runs and a run task does
+     * not: it has no handler that ends, so there is nothing for `RunTask` to run
+     * to completion.
+     */
+    get consumes(): SimEcsBoundQueueConsumer | undefined;
+    /**
+     * The handler this binding answers a request with, where it serves one.
+     *
+     * A serving container is the other thing a service runs and a run task does
+     * not: what it supplies is an answer to a request, and a run task has nothing
+     * to send it.
+     */
+    get serves(): SimEcsContainerHttpHandler | undefined;
+    /**
+     * Whether this binding targets a container declared by a family.
+     *
+     * A binding naming the family and the container name matches only that
+     * container. One naming an image repository matches any container whose
+     * image comes from it, whichever family declared it.
+     */
+    targets(family: string, container: SimEcsContainerDefinition): boolean;
+    /**
+     * Whether this binding names a container directly rather than by image.
+     *
+     * A directly named container is the more specific of the two, so it is the
+     * one that wins where both would match.
+     */
+    isNamedTarget(): boolean;
+    /**
+     * Run this binding's handler.
+     *
+     * A consuming or serving binding has none: what each supplies is the body of
+     * something else, a loop Yulin drives or a request something else brings, so
+     * there is nothing here for a task to run.
+     */
+    runHandler(): Promise<void>;
+    private refuseTargetlessBinding;
+}
+//# sourceMappingURL=sim-ecs-bound-container.d.ts.map

package/dist/service/ecs/bind/sim-ecs-bound-container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-bound-container.d.ts","sourceRoot":"","sources":["../../../../src/service/ecs/bind/sim-ecs-bound-container.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,8DAA8D,CAAC;AAE9G,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAClF,OAAO,KAAK,EACV,sBAAsB,EACtB,0BAA0B,EAC3B,MAAM,qCAAqC,CAAC;AAE7C;;;;;;;;;;;GAWG;AACH,qBAAa,oBAAoB;IAC/B,SAAgB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,SAAgB,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClD,SAAgB,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IAEpD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA2B;IAChD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA0C;IAE3E,YAAY,OAAO,EAAE,sBAAsB,EAU1C;IAED,OAAO,CAAC,MAAM,CAAC,SAAS;IAUxB;;;;;;OAMG;IACH,IAAI,QAAQ,IAAI,wBAAwB,GAAG,SAAS,CAEnD;IAED;;;;;;OAMG;IACH,IAAI,MAAM,IAAI,0BAA0B,GAAG,SAAS,CAEnD;IAED;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,yBAAyB,GAAG,OAAO,CAMrE;IAED;;;;;OAKG;IACH,aAAa,IAAI,OAAO,CAEvB;IAED;;;;;;OAMG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAWhC;IAED,OAAO,CAAC,uBAAuB;CAiBhC"}

package/dist/service/ecs/bind/sim-ecs-bound-container.js

@@ -0,0 +1,105 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { SimCfnImageRepositoryTarget } from "../../cloudformation/bind/validate/sim-cfn-image-repository-target.js";
+import { SimEcsBoundContainerWork } from "./sim-ecs-bound-container-work.js";
+/**
+ * One executable binding, read once and ready to be matched against.
+ *
+ * A binding is checked as it is made rather than when a task runs it. Binding
+ * is something a test does while setting up, so a binding that could never
+ * match anything is worth refusing there, where the mistake is.
+ *
+ * The image repository is matched by the same target the CloudFormation
+ * bindings use, so a repository means the same thing to a container as it does
+ * to a container image Lambda function: the registry host and the repository
+ * name have to match, and the tag is ignored on both sides.
+ */
+export class SimEcsBoundContainer {
+    family;
+    containerName;
+    imageRepository;
+    work;
+    repositoryTarget;
+    constructor(binding) {
+        this.family = binding.family;
+        this.containerName = binding.containerName;
+        this.imageRepository = binding.imageRepository;
+        this.repositoryTarget = SimEcsBoundContainer.targetFor(binding.imageRepository);
+        this.work = new SimEcsBoundContainerWork(binding);
+        this.refuseTargetlessBinding();
+    }
+    static targetFor(imageRepository) {
+        if (imageRepository === undefined || imageRepository === "") {
+            return undefined;
+        }
+        return new SimCfnImageRepositoryTarget(imageRepository);
+    }
+    /**
+     * The queue this binding consumes, where it consumes one.
+     *
+     * A consuming container is the one thing a service runs and a run task does
+     * not: it has no handler that ends, so there is nothing for `RunTask` to run
+     * to completion.
+     */
+    get consumes() {
+        return this.work.consumes;
+    }
+    /**
+     * The handler this binding answers a request with, where it serves one.
+     *
+     * A serving container is the other thing a service runs and a run task does
+     * not: what it supplies is an answer to a request, and a run task has nothing
+     * to send it.
+     */
+    get serves() {
+        return this.work.serves;
+    }
+    /**
+     * Whether this binding targets a container declared by a family.
+     *
+     * A binding naming the family and the container name matches only that
+     * container. One naming an image repository matches any container whose
+     * image comes from it, whichever family declared it.
+     */
+    targets(family, container) {
+        if (this.repositoryTarget !== undefined) {
+            return this.repositoryTarget.matchesImageUri(container.image);
+        }
+        return this.family === family && this.containerName === container.name;
+    }
+    /**
+     * Whether this binding names a container directly rather than by image.
+     *
+     * A directly named container is the more specific of the two, so it is the
+     * one that wins where both would match.
+     */
+    isNamedTarget() {
+        return this.repositoryTarget === undefined;
+    }
+    /**
+     * Run this binding's handler.
+     *
+     * A consuming or serving binding has none: what each supplies is the body of
+     * something else, a loop Yulin drives or a request something else brings, so
+     * there is nothing here for a task to run.
+     */
+    async runHandler() {
+        const { run } = this.work;
+        assertDefined(run, "This sim ECS container binding consumes a queue or serves requests, " +
+            "so it has no run handler. Create a service from the task definition " +
+            "to have Yulin poll the queue or send the container a request.");
+        await run();
+    }
+    refuseTargetlessBinding() {
+        if (this.repositoryTarget !== undefined) {
+            return;
+        }
+        if (this.family === undefined ||
+            this.family === "" ||
+            this.containerName === undefined ||
+            this.containerName === "") {
+            throw new Error("Invalid sim ECS container binding: a binding targets a container " +
+                "either by family and containerName, or by imageRepository.");
+        }
+    }
+}
+//# sourceMappingURL=sim-ecs-bound-container.js.map

package/dist/service/ecs/bind/sim-ecs-bound-container.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-bound-container.js","sourceRoot":"","sources":["../../../../src/service/ecs/bind/sim-ecs-bound-container.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,EAAE,2BAA2B,EAAE,MAAM,uEAAuE,CAAC;AAEpH,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAO7E;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,oBAAoB;IACf,MAAM,CAAqB;IAC3B,aAAa,CAAqB;IAClC,eAAe,CAAqB;IAEnC,IAAI,CAA2B;IAC/B,gBAAgB,CAA0C;IAE3E,YAAY,OAA+B;QACzC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC7B,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;QAC3C,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;QAC/C,IAAI,CAAC,gBAAgB,GAAG,oBAAoB,CAAC,SAAS,CACpD,OAAO,CAAC,eAAe,CACxB,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,IAAI,wBAAwB,CAAC,OAAO,CAAC,CAAC;QAElD,IAAI,CAAC,uBAAuB,EAAE,CAAC;IACjC,CAAC;IAEO,MAAM,CAAC,SAAS,CACtB,eAAmC;QAEnC,IAAI,eAAe,KAAK,SAAS,IAAI,eAAe,KAAK,EAAE,EAAE,CAAC;YAC5D,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,IAAI,2BAA2B,CAAC,eAAe,CAAC,CAAC;IAC1D,CAAC;IAED;;;;;;OAMG;IACH,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;IAC5B,CAAC;IAED;;;;;;OAMG;IACH,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;IAC1B,CAAC;IAED;;;;;;OAMG;IACH,OAAO,CAAC,MAAc,EAAE,SAAoC;QAC1D,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;YACxC,OAAO,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAChE,CAAC;QAED,OAAO,IAAI,CAAC,MAAM,KAAK,MAAM,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,CAAC,IAAI,CAAC;IACzE,CAAC;IAED;;;;;OAKG;IACH,aAAa;QACX,OAAO,IAAI,CAAC,gBAAgB,KAAK,SAAS,CAAC;IAC7C,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,UAAU;QACd,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC;QAE1B,aAAa,CACX,GAAG,EACH,sEAAsE;YACpE,sEAAsE;YACtE,+DAA+D,CAClE,CAAC;QAEF,MAAM,GAAG,EAAE,CAAC;IACd,CAAC;IAEO,uBAAuB;QAC7B,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;YACxC,OAAO;QACT,CAAC;QAED,IACE,IAAI,CAAC,MAAM,KAAK,SAAS;YACzB,IAAI,CAAC,MAAM,KAAK,EAAE;YAClB,IAAI,CAAC,aAAa,KAAK,SAAS;YAChC,IAAI,CAAC,aAAa,KAAK,EAAE,EACzB,CAAC;YACD,MAAM,IAAI,KAAK,CACb,mEAAmE;gBACjE,4DAA4D,CAC/D,CAAC;QACJ,CAAC;IACH,CAAC;CACF"}

package/dist/service/ecs/bind/sim-ecs-bound-queue-consumer.d.ts

@@ -0,0 +1,29 @@
+import type { SimEcsContainerQueueConsumer, SimEcsQueueMessage } from "./sim-ecs-container-binding.type.js";
+/**
+ * The queue one bound container consumes, read once as the binding is made.
+ *
+ * Everything about it is settled here rather than at the first poll, because
+ * binding is something a test does while setting up and that is where a
+ * mistake in it is worth reporting. A queue URL that names no queue, a batch
+ * size SQS would refuse and a handler that is not a function are all the same
+ * kind of mistake: the container would poll for the whole test and deliver
+ * nothing.
+ */
+export declare class SimEcsBoundQueueConsumer {
+    readonly queueUrl: string;
+    readonly queueArn: string;
+    readonly batchSize: number;
+    private readonly handler;
+    constructor(declared: SimEcsContainerQueueConsumer);
+    private static queueArnOf;
+    private static batchSizeOf;
+    private static handlerOf;
+    /**
+     * Hand one batch of messages to this container.
+     *
+     * Whatever the handler throws is left to whoever asked, because that is what
+     * decides whether the batch is deleted or goes back on the queue.
+     */
+    handle(messages: readonly SimEcsQueueMessage[]): Promise<void>;
+}
+//# sourceMappingURL=sim-ecs-bound-queue-consumer.d.ts.map

package/dist/service/ecs/bind/sim-ecs-bound-queue-consumer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-bound-queue-consumer.d.ts","sourceRoot":"","sources":["../../../../src/service/ecs/bind/sim-ecs-bound-queue-consumer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,4BAA4B,EAC5B,kBAAkB,EACnB,MAAM,qCAAqC,CAAC;AAa7C;;;;;;;;;GASG;AACH,qBAAa,wBAAwB;IACnC,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,SAAS,EAAE,MAAM,CAAC;IAElC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgC;IAExD,YAAY,QAAQ,EAAE,4BAA4B,EAKjD;IAED,OAAO,CAAC,MAAM,CAAC,UAAU;IAYzB,OAAO,CAAC,MAAM,CAAC,WAAW;IAoB1B,OAAO,CAAC,MAAM,CAAC,SAAS;IAaxB;;;;;OAKG;IACG,MAAM,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAEnE;CACF"}

package/dist/service/ecs/bind/sim-ecs-bound-queue-consumer.js

@@ -0,0 +1,71 @@
+import { sqsQueueArnOf } from "../../sqs/queue/sim-sqs-queue-arn.js";
+/**
+ * How many messages a consuming container is handed at once when it does not
+ * say, which is as many as one SQS receive will ever hand out.
+ */
+const defaultBatchSize = 10;
+/**
+ * The largest batch SQS hands out in one receive.
+ */
+const maximumBatchSize = 10;
+/**
+ * The queue one bound container consumes, read once as the binding is made.
+ *
+ * Everything about it is settled here rather than at the first poll, because
+ * binding is something a test does while setting up and that is where a
+ * mistake in it is worth reporting. A queue URL that names no queue, a batch
+ * size SQS would refuse and a handler that is not a function are all the same
+ * kind of mistake: the container would poll for the whole test and deliver
+ * nothing.
+ */
+export class SimEcsBoundQueueConsumer {
+    queueUrl;
+    queueArn;
+    batchSize;
+    handler;
+    constructor(declared) {
+        this.queueUrl = declared.queueUrl;
+        this.queueArn = SimEcsBoundQueueConsumer.queueArnOf(declared.queueUrl);
+        this.batchSize = SimEcsBoundQueueConsumer.batchSizeOf(declared.batchSize);
+        this.handler = SimEcsBoundQueueConsumer.handlerOf(declared.handler);
+    }
+    static queueArnOf(queueUrl) {
+        try {
+            return sqsQueueArnOf(queueUrl);
+        }
+        catch (error) {
+            throw new Error("Invalid sim ECS container binding: a consuming container names its " +
+                "queue by the URL CreateQueue answered with.", { cause: error });
+        }
+    }
+    static batchSizeOf(batchSize) {
+        if (batchSize === undefined) {
+            return defaultBatchSize;
+        }
+        if (!Number.isSafeInteger(batchSize) ||
+            batchSize < 1 ||
+            batchSize > maximumBatchSize) {
+            throw new RangeError(`Invalid sim ECS container binding: a batch size of ${batchSize} is ` +
+                `not one SQS hands out, which is a whole number from 1 to ` +
+                `${maximumBatchSize}.`);
+        }
+        return batchSize;
+    }
+    static handlerOf(handler) {
+        if (typeof handler !== "function") {
+            throw new TypeError("Invalid sim ECS container binding: a consuming container needs a " +
+                "handler, which is what its loop would do with a batch of messages.");
+        }
+        return handler;
+    }
+    /**
+     * Hand one batch of messages to this container.
+     *
+     * Whatever the handler throws is left to whoever asked, because that is what
+     * decides whether the batch is deleted or goes back on the queue.
+     */
+    async handle(messages) {
+        await this.handler(messages);
+    }
+}
+//# sourceMappingURL=sim-ecs-bound-queue-consumer.js.map

package/dist/service/ecs/bind/sim-ecs-bound-queue-consumer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-bound-queue-consumer.js","sourceRoot":"","sources":["../../../../src/service/ecs/bind/sim-ecs-bound-queue-consumer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAOrE;;;GAGG;AACH,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAE5B;;GAEG;AACH,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAE5B;;;;;;;;;GASG;AACH,MAAM,OAAO,wBAAwB;IACnB,QAAQ,CAAS;IACjB,QAAQ,CAAS;IACjB,SAAS,CAAS;IAEjB,OAAO,CAAgC;IAExD,YAAY,QAAsC;QAChD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC;QAClC,IAAI,CAAC,QAAQ,GAAG,wBAAwB,CAAC,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACvE,IAAI,CAAC,SAAS,GAAG,wBAAwB,CAAC,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QAC1E,IAAI,CAAC,OAAO,GAAG,wBAAwB,CAAC,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IACtE,CAAC;IAEO,MAAM,CAAC,UAAU,CAAC,QAAgB;QACxC,IAAI,CAAC;YACH,OAAO,aAAa,CAAC,QAAQ,CAAC,CAAC;QACjC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CACb,qEAAqE;gBACnE,6CAA6C,EAC/C,EAAE,KAAK,EAAE,KAAK,EAAE,CACjB,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,MAAM,CAAC,WAAW,CAAC,SAA6B;QACtD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAO,gBAAgB,CAAC;QAC1B,CAAC;QAED,IACE,CAAC,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC;YAChC,SAAS,GAAG,CAAC;YACb,SAAS,GAAG,gBAAgB,EAC5B,CAAC;YACD,MAAM,IAAI,UAAU,CAClB,sDAAsD,SAAS,MAAM;gBACnE,2DAA2D;gBAC3D,GAAG,gBAAgB,GAAG,CACzB,CAAC;QACJ,CAAC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,MAAM,CAAC,SAAS,CACtB,OAAsC;QAEtC,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE,CAAC;YAClC,MAAM,IAAI,SAAS,CACjB,mEAAmE;gBACjE,oEAAoE,CACvE,CAAC;QACJ,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,MAAM,CAAC,QAAuC;QAClD,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC/B,CAAC;CACF"}

package/dist/service/ecs/bind/sim-ecs-container-binding.type.d.ts

@@ -0,0 +1,110 @@
+import type { SimSqsPollMessage } from "../../sqs/poll/sim-sqs-poll-message.js";
+/**
+ * One message as a consuming container is handed it.
+ *
+ * These are the queue's own field names, which is what a container reading a
+ * queue with the SDK gets back from `ReceiveMessage`.
+ */
+export type SimEcsQueueMessage = SimSqsPollMessage;
+/**
+ * What a bound container does with a batch of messages from its queue.
+ *
+ * This is the body of the loop a real worker container writes, rather than the
+ * loop: returning means the batch was handled and can be deleted, and throwing
+ * means it was not, which leaves it to come back after the visibility timeout.
+ */
+export type SimEcsContainerConsumeHandler = (messages: readonly SimEcsQueueMessage[]) => void | Promise<void>;
+/**
+ * The queue a bound container consumes, and how.
+ *
+ * The queue is named by its URL, since that is what `CreateQueue` answers with
+ * and what a container's own environment usually carries. A batch size is how
+ * many messages the handler is given at once, up to the ten SQS will hand out
+ * in one receive.
+ */
+export interface SimEcsContainerQueueConsumer {
+    readonly queueUrl: string;
+    readonly batchSize?: number;
+    readonly handler: SimEcsContainerConsumeHandler;
+}
+/**
+ * What a bound container does when a task runs it.
+ *
+ * This is the shape of a job container: it does its work and returns, and the
+ * task stops once it has. Returning is a clean exit, and throwing is a
+ * non-zero one.
+ */
+export type SimEcsContainerRunHandler = () => void | Promise<void>;
+/**
+ * What a bound container does when an HTTP request reaches it.
+ *
+ * This is the shape of a service container behind a load balancer. It is
+ * fetch-style, matching what a simulated AWS service controller already
+ * answers a served request with, so a container and a Lambda function behind
+ * the same listener answer in the same terms.
+ *
+ * The handler is called once per request a load balancer routes to the
+ * container, with the container's environment and the task Role, rather than
+ * once per task the service is keeping running.
+ */
+export type SimEcsContainerHttpHandler = (request: Request) => Response | Promise<Response>;
+/**
+ * Which container an executable binding targets.
+ *
+ * A binding names either the container directly, by the family that declares
+ * it and its container name, or the image repository the container declares.
+ * The repository form covers a container whose image tag changes with every
+ * build, which is every container built by CDK or by a pipeline.
+ */
+export type SimEcsContainerBindingTarget = {
+    readonly family: string;
+    readonly containerName: string;
+    readonly imageRepository?: never;
+} | {
+    readonly imageRepository: string;
+    readonly family?: never;
+    readonly containerName?: never;
+};
+/**
+ * What a bound container runs, which is one shape or another.
+ *
+ * A `run` handler is a job container, which does its work and exits. A
+ * `consumes` declaration is a worker container, which a real image would put in
+ * an endless receive-handle-delete loop. Yulin runs that loop and the binding
+ * supplies its body, because an endless loop in a single Node.js process would
+ * never yield to the test running it. An `http` handler is a service container
+ * behind a load balancer, which answers the requests routed to it.
+ */
+export type SimEcsContainerBindingHandler = {
+    readonly run: SimEcsContainerRunHandler;
+    readonly http?: never;
+    readonly consumes?: never;
+} | {
+    readonly http: SimEcsContainerHttpHandler;
+    readonly run?: never;
+    readonly consumes?: never;
+} | {
+    readonly consumes: SimEcsContainerQueueConsumer;
+    readonly run?: never;
+    readonly http?: never;
+};
+/**
+ * A real in-process handler bound to a container a task definition declares.
+ *
+ * Yulin never looks inside a container image, so a task can only run code the
+ * test supplied. A binding is how that code is supplied, and what it is
+ * matched on is either the container's name in its family or the repository
+ * its image comes from.
+ *
+ * ```typescript
+ * simAws.ecs().bindContainer({
+ *   family: "orders-worker",
+ *   containerName: "app",
+ *   run: async () => {
+ *     await processOutstandingOrders();
+ *   },
+ * });
+ * ```
+ */
+export type SimEcsContainerBinding = SimEcsContainerBindingTarget & SimEcsContainerBindingHandler;
+//# sourceMappingURL=sim-ecs-container-binding.type.d.ts.map

package/dist/service/ecs/bind/sim-ecs-container-binding.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-container-binding.type.d.ts","sourceRoot":"","sources":["../../../../src/service/ecs/bind/sim-ecs-container-binding.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAEhF;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,iBAAiB,CAAC;AAEnD;;;;;;GAMG;AACH,MAAM,MAAM,6BAA6B,GAAG,CAC1C,QAAQ,EAAE,SAAS,kBAAkB,EAAE,KACpC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B;;;;;;;GAOG;AACH,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,6BAA6B,CAAC;CACjD;AAED;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,GAAG,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,0BAA0B,GAAG,CACvC,OAAO,EAAE,OAAO,KACb,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAElC;;;;;;;GAOG;AACH,MAAM,MAAM,4BAA4B,GACpC;IACE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,eAAe,CAAC,EAAE,KAAK,CAAC;CAClC,GACD;IACE,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC;IACxB,QAAQ,CAAC,aAAa,CAAC,EAAE,KAAK,CAAC;CAChC,CAAC;AAEN;;;;;;;;;GASG;AACH,MAAM,MAAM,6BAA6B,GACrC;IACE,QAAQ,CAAC,GAAG,EAAE,yBAAyB,CAAC;IACxC,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC;CAC3B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,0BAA0B,CAAC;IAC1C,QAAQ,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC;CAC3B,GACD;IACE,QAAQ,CAAC,QAAQ,EAAE,4BAA4B,CAAC;IAChD,QAAQ,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC;CACvB,CAAC;AAEN;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,sBAAsB,GAAG,4BAA4B,GAC/D,6BAA6B,CAAC"}

package/dist/service/ecs/bind/sim-ecs-container-binding.type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sim-ecs-container-binding.type.js.map

package/dist/service/ecs/bind/sim-ecs-container-binding.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-container-binding.type.js","sourceRoot":"","sources":["../../../../src/service/ecs/bind/sim-ecs-container-binding.type.ts"],"names":[],"mappings":""}

package/dist/service/ecs/bind/sim-ecs-container-bindings.d.ts

@@ -0,0 +1,28 @@
+import type { SimEcsContainerDefinition } from "../task-definition/container/sim-ecs-container-definition.js";
+import { SimEcsBoundContainer } from "./sim-ecs-bound-container.js";
+import type { SimEcsContainerBinding } from "./sim-ecs-container-binding.type.js";
+/**
+ * The executable bindings one simulated ECS scope holds.
+ *
+ * Bindings belong to the scope they were made in, as the task definitions they
+ * target do. A binding made against one Account and Region reaches no
+ * container in another.
+ *
+ * Two bindings can match the same container, so the order they are searched in
+ * is part of the behaviour: a binding naming the container directly beats one
+ * naming an image repository, and the most recently made of equally specific
+ * bindings wins. That makes binding the same container again replace what it
+ * runs, which is what a test setting up a case wants.
+ */
+export declare class SimEcsContainerBindings {
+    private readonly bindings;
+    /**
+     * Hold an executable binding, refusing one that could never match.
+     */
+    add(binding: SimEcsContainerBinding): void;
+    /**
+     * The binding a container of a family runs, if anything is bound to it.
+     */
+    find(family: string, container: SimEcsContainerDefinition): SimEcsBoundContainer | undefined;
+}
+//# sourceMappingURL=sim-ecs-container-bindings.d.ts.map

package/dist/service/ecs/bind/sim-ecs-container-bindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-container-bindings.d.ts","sourceRoot":"","sources":["../../../../src/service/ecs/bind/sim-ecs-container-bindings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,8DAA8D,CAAC;AAC9G,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAElF;;;;;;;;;;;;GAYG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IAEvD;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,sBAAsB,GAAG,IAAI,CAEzC;IAED;;OAEG;IACH,IAAI,CACF,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,yBAAyB,GACnC,oBAAoB,GAAG,SAAS,CAQlC;CACF"}

package/dist/service/ecs/bind/sim-ecs-container-bindings.js

@@ -0,0 +1,33 @@
+import { SimEcsBoundContainer } from "./sim-ecs-bound-container.js";
+/**
+ * The executable bindings one simulated ECS scope holds.
+ *
+ * Bindings belong to the scope they were made in, as the task definitions they
+ * target do. A binding made against one Account and Region reaches no
+ * container in another.
+ *
+ * Two bindings can match the same container, so the order they are searched in
+ * is part of the behaviour: a binding naming the container directly beats one
+ * naming an image repository, and the most recently made of equally specific
+ * bindings wins. That makes binding the same container again replace what it
+ * runs, which is what a test setting up a case wants.
+ */
+export class SimEcsContainerBindings {
+    bindings = [];
+    /**
+     * Hold an executable binding, refusing one that could never match.
+     */
+    add(binding) {
+        this.bindings.push(new SimEcsBoundContainer(binding));
+    }
+    /**
+     * The binding a container of a family runs, if anything is bound to it.
+     */
+    find(family, container) {
+        const matching = this.bindings
+            .filter((binding) => binding.targets(family, container))
+            .toReversed();
+        return (matching.find((binding) => binding.isNamedTarget()) ?? matching.at(0));
+    }
+}
+//# sourceMappingURL=sim-ecs-container-bindings.js.map

package/dist/service/ecs/bind/sim-ecs-container-bindings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-ecs-container-bindings.js","sourceRoot":"","sources":["../../../../src/service/ecs/bind/sim-ecs-container-bindings.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAGpE;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,uBAAuB;IACjB,QAAQ,GAA2B,EAAE,CAAC;IAEvD;;OAEG;IACH,GAAG,CAAC,OAA+B;QACjC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC;IACxD,CAAC;IAED;;OAEG;IACH,IAAI,CACF,MAAc,EACd,SAAoC;QAEpC,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ;aAC3B,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;aACvD,UAAU,EAAE,CAAC;QAEhB,OAAO,CACL,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CACtE,CAAC;IACJ,CAAC;CACF"}

package/dist/service/ecs/cfn/bind/sim-cfn-ecs-binding-work.d.ts

@@ -0,0 +1,13 @@
+import type { SimEcsContainerBindingHandler } from "../../bind/sim-ecs-container-binding.type.js";
+import type { SimCfnEcsContainerBinding } from "./sim-cfn-ecs-container-binding.type.js";
+/**
+ * What a deploy-time binding does, without the target it named.
+ *
+ * A binding naming a task definition Resource has its target rewritten into the
+ * family that Resource registers under, and everything else about it goes
+ * through untouched. Taking the target keys off is what leaves the handler
+ * behind, whichever of the shapes it is, so a handler simulated ECS refuses is
+ * refused there rather than being sorted into shapes twice on the way.
+ */
+export declare function simCfnEcsBindingWork(binding: SimCfnEcsContainerBinding): SimEcsContainerBindingHandler;
+//# sourceMappingURL=sim-cfn-ecs-binding-work.d.ts.map