@kensio/yulin 1.21.26 → 1.21.27

package/dist/service/eventbridge/command/source/sim-event-bridge-put-partner-events.d.ts

@@ -0,0 +1,41 @@
+import type { BackgroundScheduler } from "../../../../util/background/background.js";
+import type { SimAwsAccountRegionScope } from "../../../aws/sim-aws-account-region-scope.js";
+import type { SimEventBridgeRouter } from "../../routing/sim-event-bridge-router.js";
+import type { SimPartnerEventSourceStore } from "../../source/sim-partner-event-source-store.js";
+import type { SimPutPartnerEventsCommand, SimPutPartnerEventsCommandOutput } from "./source.command.js";
+interface SimEventBridgePutPartnerEventsProperties {
+    readonly sources: SimPartnerEventSourceStore;
+    readonly accountRegionScope: SimAwsAccountRegionScope;
+    readonly clock: BackgroundScheduler;
+    readonly router: SimEventBridgeRouter;
+}
+/**
+ * Puts events onto partner event buses as their SaaS partner would.
+ *
+ * Each entry's `Source` names the partner event source it comes from, and the
+ * event goes to the bus of the same name. An event for a source with no bus is
+ * dropped. Real EventBridge documents that it keeps nothing a partner sends
+ * before the receiving Account creates the bus.
+ *
+ * Nothing is authorized. The partner sends from its own Account, which is
+ * outside the simulation, and the receiving Account's IAM has no say in it.
+ */
+export declare class SimEventBridgePutPartnerEvents {
+    private readonly sources;
+    private readonly clock;
+    private readonly router;
+    private readonly reader;
+    constructor(properties: SimEventBridgePutPartnerEventsProperties);
+    /**
+     * Put a partner's events onto the buses of their sources.
+     *
+     * Every `Source` is resolved before any event is put, so a request naming a
+     * source that was never registered changes nothing.
+     */
+    handle(command: SimPutPartnerEventsCommand): SimPutPartnerEventsCommandOutput;
+    /**
+     * Put one entry onto the bus its source names.
+     */
+    private put;
+}
+export {};

package/dist/service/eventbridge/command/source/sim-event-bridge-put-partner-events.js

@@ -0,0 +1,82 @@
+import { SimEventBridgeValidationException } from "../../error/sim-event-bridge.error.js";
+import { SimEventBridgeEntryFailure } from "../put-events/sim-event-bridge-entry-failure.js";
+import { SimEventBridgeEntryReader } from "../put-events/sim-event-bridge-entry-reader.js";
+import { simEventBridgeMaximumRequestBytes, simEventBridgeRequestSize, } from "../put-events/sim-event-bridge-entry-size.js";
+/**
+ * The most entries one PutPartnerEvents request may carry.
+ */
+const maximumEntries = 20;
+/**
+ * Puts events onto partner event buses as their SaaS partner would.
+ *
+ * Each entry's `Source` names the partner event source it comes from, and the
+ * event goes to the bus of the same name. An event for a source with no bus is
+ * dropped. Real EventBridge documents that it keeps nothing a partner sends
+ * before the receiving Account creates the bus.
+ *
+ * Nothing is authorized. The partner sends from its own Account, which is
+ * outside the simulation, and the receiving Account's IAM has no say in it.
+ */
+export class SimEventBridgePutPartnerEvents {
+    sources;
+    clock;
+    router;
+    reader;
+    constructor(properties) {
+        this.sources = properties.sources;
+        this.clock = properties.clock;
+        this.router = properties.router;
+        this.reader = new SimEventBridgeEntryReader({
+            accountRegionScope: properties.accountRegionScope,
+        });
+    }
+    /**
+     * Put a partner's events onto the buses of their sources.
+     *
+     * Every `Source` is resolved before any event is put, so a request naming a
+     * source that was never registered changes nothing.
+     */
+    handle(command) {
+        const entries = partnerRequestEntries(command.input.Entries ?? []);
+        for (const entry of entries) {
+            if (entry.Source !== undefined) {
+                this.sources.require(entry.Source);
+            }
+        }
+        const at = this.clock.now();
+        const results = entries.map((entry) => this.put(entry, at));
+        return {
+            $metadata: {},
+            Entries: results,
+            FailedEntryCount: results.filter((result) => result.ErrorCode !== undefined).length,
+        };
+    }
+    /**
+     * Put one entry onto the bus its source names.
+     */
+    put(entry, at) {
+        const read = this.reader.read(entry, at);
+        if (read instanceof SimEventBridgeEntryFailure) {
+            return read.toResultEntry();
+        }
+        this.router.deliver(read.source, read);
+        return { EventId: read.id };
+    }
+}
+/**
+ * Refuse a request carrying no entries, too many, or too many bytes.
+ */
+function partnerRequestEntries(entries) {
+    if (entries.length === 0 || entries.length > maximumEntries) {
+        throw new SimEventBridgeValidationException(`Invalid parameter: Entries Reason: a PutPartnerEvents request carries ` +
+            `between 1 and ${String(maximumEntries)} entries, and this one ` +
+            `carries ${String(entries.length)}`);
+    }
+    const size = simEventBridgeRequestSize(entries);
+    if (size > simEventBridgeMaximumRequestBytes) {
+        throw new SimEventBridgeValidationException(`Total size of the entries in the request is ${String(size)} bytes, ` +
+            `which is over the ${String(simEventBridgeMaximumRequestBytes)} byte ` +
+            `limit.`);
+    }
+    return entries;
+}

package/dist/service/eventbridge/command/source/source.command.d.ts

@@ -0,0 +1,59 @@
+import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
+/**
+ * Minimal structural sim EventBridge DescribeEventSource command.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/eventbridge/command/DescribeEventSourceCommand/
+ */
+export interface SimDescribeEventSourceCommand {
+    readonly input: SimDescribeEventSourceCommandInput;
+}
+export interface SimDescribeEventSourceCommandInput {
+    readonly Name?: string | undefined;
+}
+export interface SimDescribeEventSourceCommandOutput {
+    readonly Arn?: string | undefined;
+    readonly CreatedBy?: string | undefined;
+    readonly CreationTime?: Date | undefined;
+    readonly Name?: string | undefined;
+    readonly State?: string | undefined;
+    readonly $metadata: SimResponseMetadata;
+}
+/**
+ * One event as a partner's PutPartnerEvents request carries it.
+ *
+ * https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutPartnerEventsRequestEntry.html
+ */
+export interface SimPutPartnerEventsRequestEntry {
+    readonly Source?: string | undefined;
+    readonly DetailType?: string | undefined;
+    readonly Detail?: string | undefined;
+    readonly Resources?: readonly string[] | undefined;
+    readonly Time?: Date | undefined;
+}
+/**
+ * One partner entry's result, which carries either an event id or a failure.
+ */
+export interface SimPutPartnerEventsResultEntry {
+    readonly EventId?: string | undefined;
+    readonly ErrorCode?: string | undefined;
+    readonly ErrorMessage?: string | undefined;
+}
+/**
+ * Minimal structural sim EventBridge PutPartnerEvents command.
+ *
+ * A SaaS partner sends this from its own Account. In a simulation it is a
+ * test acting as the partner, through `SimEventBridge.putPartnerEvents`.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/eventbridge/command/PutPartnerEventsCommand/
+ */
+export interface SimPutPartnerEventsCommand {
+    readonly input: SimPutPartnerEventsCommandInput;
+}
+export interface SimPutPartnerEventsCommandInput {
+    readonly Entries?: readonly SimPutPartnerEventsRequestEntry[] | undefined;
+}
+export interface SimPutPartnerEventsCommandOutput {
+    readonly Entries?: readonly SimPutPartnerEventsResultEntry[] | undefined;
+    readonly FailedEntryCount?: number | undefined;
+    readonly $metadata: SimResponseMetadata;
+}

package/dist/service/eventbridge/command/source/source.command.js

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

package/dist/service/eventbridge/command/target/sim-event-bridge-target-commands.js

@@ -54,6 +54,8 @@ export class SimEventBridgeTargetCommands {
             Input: target.input,
             RoleArn: target.ecs?.roleArn,
             EcsParameters: target.ecs?.task.parameters.declared,
+            RetryPolicy: target.retryPolicy?.declared,
+            DeadLetterConfig: target.deadLetterConfig?.declared,
         }));
         const page = new SimEventBridgePage(listed, input.Limit, input.NextToken);
         return {

package/dist/service/eventbridge/command/target/sim-event-bridge-unsimulated-target-input.js

@@ -3,8 +3,8 @@ import { SimEventBridgeUnsimulatedInputException } from "../../error/sim-event-b
  * The properties that change what a target receives, or whether it receives
  * anything at all.
  *
- * Ignoring one would leave a test believing in a transformation, a retry or a
- * dead letter queue that never happened.
+ * Ignoring one would leave a test believing in a transformation that never
+ * happened.
  */
 const behaviourRefusals = [
     [
@@ -17,16 +17,6 @@ const behaviourRefusals = [
         "Target InputTransformer is not simulated, so PutTargets refuses one " +
             "rather than sending the untransformed event",
     ],
-    [
-        (target) => target.DeadLetterConfig,
-        "Target dead letter queues are not simulated, so PutTargets refuses a " +
-            "DeadLetterConfig rather than dropping undelivered events silently",
-    ],
-    [
-        (target) => target.RetryPolicy,
-        "Target retry policies are not simulated, so PutTargets refuses a " +
-            "RetryPolicy rather than delivering once and calling it retried",
-    ],
     [
         (target) => target.SqsParameters,
         "SqsParameters names a FIFO queue's message group, and FIFO queues are " +

package/dist/service/eventbridge/command/target/target.command.d.ts

@@ -1,11 +1,14 @@
 import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
 import type { SimEcsTargetParametersType } from "../../../ecs/target/sim-ecs-target-parameters.js";
+import type { SimEventTargetDeadLetterConfigInput } from "../../target/sim-event-target-dead-letter-config.js";
+import type { SimEventTargetRetryPolicyInput } from "../../target/sim-event-target-retry-policy.js";
 /**
  * One target as a request carries it, and as ListTargetsByRule reports it.
  *
- * The properties beyond `Id`, `Arn`, `Input`, `RoleArn` and `EcsParameters`
- * are the ones real EventBridge takes and this simulation refuses, kept in the
- * shape so a request carrying one is recognised and named rather than ignored.
+ * The properties beyond `Id`, `Arn`, `Input`, `RoleArn`, `EcsParameters`,
+ * `DeadLetterConfig` and `RetryPolicy` are the ones real EventBridge takes and
+ * this simulation refuses. They are kept in the shape so a request carrying
+ * one is recognised and named.
  */
 export interface SimEventBridgeTarget {
     readonly Id?: string | undefined;
@@ -14,8 +17,8 @@ export interface SimEventBridgeTarget {
     readonly InputPath?: string | undefined;
     readonly InputTransformer?: object | undefined;
     readonly RoleArn?: string | undefined;
-    readonly DeadLetterConfig?: object | undefined;
-    readonly RetryPolicy?: object | undefined;
+    readonly DeadLetterConfig?: SimEventTargetDeadLetterConfigInput | undefined;
+    readonly RetryPolicy?: SimEventTargetRetryPolicyInput | undefined;
     readonly SqsParameters?: object | undefined;
     readonly KinesisParameters?: object | undefined;
     readonly EcsParameters?: SimEcsTargetParametersType | undefined;

package/dist/service/eventbridge/delivery/sim-aws-event-bridge-delivery-targets.d.ts

@@ -1,5 +1,5 @@
 import type { SimAws } from "../../aws/sim-aws.js";
-import type { SimEventBridgeDeliveryRequest, SimEventBridgeDeliveryTargets } from "./sim-event-bridge-delivery.js";
+import type { SimEventBridgeDeadLetterRequest, SimEventBridgeDeliveryRequest, SimEventBridgeDeliveryTargets } from "./sim-event-bridge-delivery.js";
 interface SimAwsEventBridgeDeliveryTargetsProperties {
     readonly simAws: SimAws;
 }
@@ -21,6 +21,11 @@ export declare class SimAwsEventBridgeDeliveryTargets implements SimEventBridgeD
      * Send one event to the target its ARN names.
      */
     deliver(request: SimEventBridgeDeliveryRequest): Promise<void>;
+    /**
+     * Send an event EventBridge gave up on to the dead-letter queue its target
+     * names, in the queue's own Account and Region.
+     */
+    deadLetter(request: SimEventBridgeDeadLetterRequest): Promise<void>;
     /**
      * Hand the delivery to the one destination that knows this service.
      */

package/dist/service/eventbridge/delivery/sim-aws-event-bridge-delivery-targets.js

@@ -1,4 +1,6 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
 import { SimEventBridgeDeliveryFunction } from "./sim-event-bridge-delivery-function.js";
+import { SimEventBridgeDeadLetterQueue } from "./sim-event-bridge-dead-letter-queue.js";
 import { SimEventBridgeDeliveryQueue } from "./sim-event-bridge-delivery-queue.js";
 import { SimEventBridgeDeliveryTask } from "./sim-event-bridge-delivery-task.js";
 import { SimEventBridgeDeliveryTopic } from "./sim-event-bridge-delivery-topic.js";
@@ -26,6 +28,20 @@ export class SimAwsEventBridgeDeliveryTargets {
         const scope = this.simAws.accountRegionScope(arn.accountId, arn.regionName);
         await this.deliverTo(arn.service, { request, scope });
     }
+    /**
+     * Send an event EventBridge gave up on to the dead-letter queue its target
+     * names, in the queue's own Account and Region.
+     */
+    async deadLetter(request) {
+        const config = request.delivery.target.deadLetterConfig;
+        assertDefined(config, "A dead letter requires a dead-letter queue");
+        const { accountId, regionName, name } = config.queue;
+        const scope = this.simAws.accountRegionScope(accountId, regionName);
+        await new SimEventBridgeDeadLetterQueue({ scope }).deliver(request, {
+            name,
+            arn: config.arn,
+        });
+    }
     /**
      * Hand the delivery to the one destination that knows this service.
      */

package/dist/service/eventbridge/delivery/sim-event-bridge-dead-letter-attributes.d.ts

@@ -0,0 +1,9 @@
+import type { SimEventBridgeDeadLetterRequest } from "./sim-event-bridge-delivery.js";
+import type { SimEventBridgeStringAttribute } from "./sim-event-bridge-queue-message.js";
+/**
+ * The message attributes EventBridge documents for a dead letter.
+ *
+ * `EXHAUSTED_RETRY_CONDITION` is there only for a failure that was retried
+ * until a limit ran out.
+ */
+export declare function simEventBridgeDeadLetterAttributes(request: SimEventBridgeDeadLetterRequest): Readonly<Record<string, SimEventBridgeStringAttribute>>;

package/dist/service/eventbridge/delivery/sim-event-bridge-dead-letter-attributes.js

@@ -0,0 +1,47 @@
+import { SimEventBridgeDeliveryNotPermitted, SimEventBridgeTargetNotFound, } from "../error/sim-event-bridge-delivery.error.js";
+/**
+ * The `ERROR_CODE` a dead letter carries for a failure.
+ *
+ * EventBridge documents a list of codes without saying which failure gets
+ * which. A target that refuses EventBridge is `NO_PERMISSIONS`, a target that
+ * is not there is `NO_RESOURCE`, and anything else the target answered with
+ * is `ERROR_FROM_TARGET`.
+ */
+function errorCode(error) {
+    if (error instanceof SimEventBridgeDeliveryNotPermitted) {
+        return "NO_PERMISSIONS";
+    }
+    if (error instanceof SimEventBridgeTargetNotFound) {
+        return "NO_RESOURCE";
+    }
+    return "ERROR_FROM_TARGET";
+}
+function errorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+/**
+ * The message attributes EventBridge documents for a dead letter.
+ *
+ * `EXHAUSTED_RETRY_CONDITION` is there only for a failure that was retried
+ * until a limit ran out.
+ */
+export function simEventBridgeDeadLetterAttributes(request) {
+    const { delivery, error, retryAttempts, exhaustedCondition } = request;
+    const attributes = {
+        RULE_ARN: delivery.ruleArn,
+        TARGET_ARN: delivery.target.arn.value,
+        ERROR_CODE: errorCode(error),
+        ERROR_MESSAGE: errorMessage(error),
+        RETRY_ATTEMPTS: String(retryAttempts),
+        ...(exhaustedCondition !== undefined && {
+            EXHAUSTED_RETRY_CONDITION: exhaustedCondition,
+        }),
+    };
+    return Object.fromEntries(Object.entries(attributes).map(([name, value]) => [
+        name,
+        { DataType: "String", StringValue: value },
+    ]));
+}

package/dist/service/eventbridge/delivery/sim-event-bridge-dead-letter-queue.d.ts

@@ -0,0 +1,24 @@
+import type { SimAwsAccountRegionContainer } from "../../aws/sim-aws-account-region-scope.js";
+import { type SimEventBridgeDeadLetterRequest } from "./sim-event-bridge-delivery.js";
+interface SimEventBridgeDeadLetterQueueProperties {
+    readonly scope: SimAwsAccountRegionContainer;
+}
+/**
+ * A target's dead-letter queue, in the Account and Region its ARN names.
+ *
+ * The message body is the event, as JSON, whatever `Input` the target had.
+ * The message attributes say which rule and target gave up on it, and why.
+ */
+export declare class SimEventBridgeDeadLetterQueue {
+    private readonly scope;
+    constructor(properties: SimEventBridgeDeadLetterQueueProperties);
+    /**
+     * Put an event EventBridge gave up on onto the queue, if it admits
+     * EventBridge for this rule.
+     */
+    deliver(request: SimEventBridgeDeadLetterRequest, queue: {
+        readonly name: string;
+        readonly arn: string;
+    }): Promise<void>;
+}
+export {};

package/dist/service/eventbridge/delivery/sim-event-bridge-dead-letter-queue.js

@@ -0,0 +1,28 @@
+import { simEventBridgeDeadLetterAttributes } from "./sim-event-bridge-dead-letter-attributes.js";
+import { simEventBridgeDeliverySource, } from "./sim-event-bridge-delivery.js";
+import { sendEventBridgeQueueMessage } from "./sim-event-bridge-queue-message.js";
+/**
+ * A target's dead-letter queue, in the Account and Region its ARN names.
+ *
+ * The message body is the event, as JSON, whatever `Input` the target had.
+ * The message attributes say which rule and target gave up on it, and why.
+ */
+export class SimEventBridgeDeadLetterQueue {
+    scope;
+    constructor(properties) {
+        this.scope = properties.scope;
+    }
+    /**
+     * Put an event EventBridge gave up on onto the queue, if it admits
+     * EventBridge for this rule.
+     */
+    async deliver(request, queue) {
+        await sendEventBridgeQueueMessage(this.scope, {
+            queueName: queue.name,
+            queueArn: queue.arn,
+            body: JSON.stringify(request.delivery.event.toEnvelope()),
+            attributes: simEventBridgeDeadLetterAttributes(request),
+            source: simEventBridgeDeliverySource(request.delivery),
+        });
+    }
+}

package/dist/service/eventbridge/delivery/sim-event-bridge-delivery-attempt.d.ts

@@ -0,0 +1,41 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimEventBridgeDeliveryRequest, SimEventBridgeDeliveryTargets } from "./sim-event-bridge-delivery.js";
+interface SimEventBridgeDeliveryAttemptProperties {
+    readonly request: SimEventBridgeDeliveryRequest;
+    readonly endpoints: SimEventBridgeDeliveryTargets;
+    readonly background: BackgroundScheduler;
+    readonly record: (error: unknown) => void;
+}
+/**
+ * One event's delivery to one target, across its first attempt and any
+ * retries.
+ *
+ * A target with a `RetryPolicy` has a failed attempt retried on the
+ * simulation's clock, one second later, then two, four and so on. Retries stop
+ * at the policy's retry limit, or at its event age counted from the first
+ * attempt. A missing target or a refusal is never retried, because the same
+ * request gets the same answer, and EventBridge sends those straight to the
+ * dead-letter queue.
+ *
+ * An event given up on goes to the target's dead-letter queue where it names
+ * one. A failure is recorded where it names none, or where the dead-letter
+ * queue refuses it in turn.
+ */
+export declare class SimEventBridgeDeliveryAttempt {
+    private readonly properties;
+    private readonly firstAttemptAt;
+    private retryAttempts;
+    constructor(properties: SimEventBridgeDeliveryAttemptProperties);
+    /**
+     * Make the first attempt.
+     */
+    start(): Promise<void>;
+    private attempt;
+    private failed;
+    /**
+     * The first retry waits one second, and every following wait doubles.
+     */
+    private retryDueTime;
+    private abandon;
+}
+export {};

package/dist/service/eventbridge/delivery/sim-event-bridge-delivery-attempt.js

@@ -0,0 +1,97 @@
+import { SimEventBridgeDeliveryNotPermitted, SimEventBridgeTargetNotFound, } from "../error/sim-event-bridge-delivery.error.js";
+const millisecondsPerSecond = 1000;
+/**
+ * One event's delivery to one target, across its first attempt and any
+ * retries.
+ *
+ * A target with a `RetryPolicy` has a failed attempt retried on the
+ * simulation's clock, one second later, then two, four and so on. Retries stop
+ * at the policy's retry limit, or at its event age counted from the first
+ * attempt. A missing target or a refusal is never retried, because the same
+ * request gets the same answer, and EventBridge sends those straight to the
+ * dead-letter queue.
+ *
+ * An event given up on goes to the target's dead-letter queue where it names
+ * one. A failure is recorded where it names none, or where the dead-letter
+ * queue refuses it in turn.
+ */
+export class SimEventBridgeDeliveryAttempt {
+    properties;
+    firstAttemptAt;
+    retryAttempts = 0;
+    constructor(properties) {
+        this.properties = properties;
+        this.firstAttemptAt = properties.background.now();
+    }
+    /**
+     * Make the first attempt.
+     */
+    async start() {
+        await this.attempt();
+    }
+    async attempt() {
+        try {
+            await this.properties.endpoints.deliver(this.properties.request);
+        }
+        catch (error) {
+            await this.failed(error);
+        }
+    }
+    async failed(error) {
+        const policy = this.properties.request.target.retryPolicy;
+        if (policy === undefined || isPermanent(error)) {
+            await this.abandon(error, undefined);
+            return;
+        }
+        if (this.retryAttempts >= policy.maximumRetryAttempts) {
+            await this.abandon(error, "MaximumRetryAttempts");
+            return;
+        }
+        const retryDue = this.retryDueTime();
+        const expiresAt = new Date(this.firstAttemptAt.getTime() +
+            policy.maximumEventAgeInSeconds * millisecondsPerSecond);
+        if (retryDue > expiresAt) {
+            this.properties.background.scheduleAt(expiresAt, async () => {
+                await this.abandon(error, "MaximumEventAgeInSeconds");
+            });
+            return;
+        }
+        this.properties.background.scheduleAt(retryDue, async () => {
+            this.retryAttempts += 1;
+            await this.attempt();
+        });
+    }
+    /**
+     * The first retry waits one second, and every following wait doubles.
+     */
+    retryDueTime() {
+        const delaySeconds = 2 ** this.retryAttempts;
+        return new Date(this.properties.background.now().getTime() +
+            delaySeconds * millisecondsPerSecond);
+    }
+    async abandon(error, exhaustedCondition) {
+        const { request, endpoints, record } = this.properties;
+        if (request.target.deadLetterConfig === undefined) {
+            record(error);
+            return;
+        }
+        try {
+            await endpoints.deadLetter({
+                delivery: request,
+                error,
+                retryAttempts: this.retryAttempts,
+                exhaustedCondition,
+            });
+        }
+        catch (deadLetterError) {
+            record(deadLetterError);
+        }
+    }
+}
+/**
+ * Whether a failure would come back the same however often it was retried.
+ */
+function isPermanent(error) {
+    return (error instanceof SimEventBridgeDeliveryNotPermitted ||
+        error instanceof SimEventBridgeTargetNotFound);
+}

package/dist/service/eventbridge/delivery/sim-event-bridge-delivery-queue.js

@@ -1,7 +1,5 @@
-import { SimSqsServiceSendAuthorizer } from "../../sqs/command/authorize/sim-sqs-service-send-authorizer.js";
-import { SimEventBridgeDeliveryNotPermitted, SimEventBridgeTargetNotFound, } from "../error/sim-event-bridge-delivery.error.js";
-import { simEventBridgeDeliveryJson, simEventBridgeDeliverySource, simEventBridgeServicePrincipal, } from "./sim-event-bridge-delivery.js";
-import { simScopeIamAuthZ } from "../../iam/authorize/sim-iam-region-auth-z.js";
+import { simEventBridgeDeliveryJson, simEventBridgeDeliverySource, } from "./sim-event-bridge-delivery.js";
+import { sendEventBridgeQueueMessage } from "./sim-event-bridge-queue-message.js";
 /**
  * A queue a simulated rule is sending an event to, in the Account and Region
  * the target ARN names.
@@ -19,39 +17,11 @@ export class SimEventBridgeDeliveryQueue {
      * Put the event on the queue, if it admits EventBridge for this rule.
      */
     async deliver(request) {
-        const source = simEventBridgeDeliverySource(request);
-        const targetArn = request.target.arn;
-        const queue = this.scope.sqs().findQueue(targetArn.resource);
-        if (queue === undefined) {
-            throw new SimEventBridgeTargetNotFound(`${targetArn.value} is not a simulated SQS queue.`);
-        }
-        const decision = new SimSqsServiceSendAuthorizer({
-            iam: simScopeIamAuthZ(this.scope),
-        }).authorize({
-            queue,
-            servicePrincipal: simEventBridgeServicePrincipal,
-            ...source,
-        });
-        if (decision.isDenied) {
-            throw new SimEventBridgeDeliveryNotPermitted(`The queue policy of ${targetArn.value} does not allow ` +
-                `${simEventBridgeServicePrincipal} to send to it for ` +
-                `${source.sourceArn}. Grant sqs:SendMessage with the queue's ` +
-                `Policy attribute.`);
-        }
-        // Sent through the ordinary SendMessage path, so a delivered event is the
-        // same thing an SDK caller would have sent, and is authorized again on the
-        // way in.
-        await this.scope.sqs().sendMessage({
-            input: {
-                QueueUrl: queue.arn.url,
-                MessageBody: simEventBridgeDeliveryJson(request),
-            },
-        }, {
-            caller: {
-                kind: "service",
-                service: simEventBridgeServicePrincipal,
-            },
-            ...source,
+        await sendEventBridgeQueueMessage(this.scope, {
+            queueName: request.target.arn.resource,
+            queueArn: request.target.arn.value,
+            body: simEventBridgeDeliveryJson(request),
+            source: simEventBridgeDeliverySource(request),
         });
     }
 }

package/dist/service/eventbridge/delivery/sim-event-bridge-delivery-retries.test-support.d.ts

@@ -0,0 +1,25 @@
+import { SimClockControl } from "../../../util/clock/sim-clock-control.js";
+import { SimEventBridge } from "../sim-event-bridge.js";
+import type { SimEventTargetRetryPolicyInput } from "../target/sim-event-target-retry-policy.js";
+import type { SimEventBridgeDeadLetterRequest } from "./sim-event-bridge-delivery.js";
+import { type SimEventBridgeFailingTargetsOptions } from "./sim-event-bridge-failing-targets.test-support.js";
+export interface RetrySimulation {
+    readonly eventBridge: SimEventBridge;
+    readonly clock: SimClockControl;
+    readonly attempts: Date[];
+    readonly deadLetters: SimEventBridgeDeadLetterRequest[];
+}
+/**
+ * A simulated EventBridge whose targets fail as the options say.
+ */
+export declare function retrySimulation(options: SimEventBridgeFailingTargetsOptions): RetrySimulation;
+/**
+ * Add a rule with one target carrying the given retry policy and a
+ * dead-letter queue, and put one matching event.
+ */
+export declare function putOrder(simulation: RetrySimulation, target: {
+    readonly RetryPolicy?: SimEventTargetRetryPolicyInput;
+    readonly DeadLetterConfig?: {
+        readonly Arn: string;
+    };
+}): Promise<void>;