@kensio/yulin 1.21.26 → 1.21.28

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>;

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

@@ -0,0 +1,60 @@
+import { BackgroundTasks } from "../../../util/background/background.js";
+import { SimClockControl } from "../../../util/clock/sim-clock-control.js";
+import { SimControllableClock } from "../../../util/clock/sim-controllable-clock.js";
+import { SimFixedClock } from "../../../util/clock/sim-clock.js";
+import { SimEventBridge } from "../sim-event-bridge.js";
+import { SimEventBridgeFailingTargets, } from "./sim-event-bridge-failing-targets.test-support.js";
+const startedAt = new Date("2026-10-07T09:00:00.000Z");
+/**
+ * A simulated EventBridge whose targets fail as the options say.
+ */
+export function retrySimulation(options) {
+    const clock = new SimControllableClock({
+        base: new SimFixedClock(startedAt),
+    });
+    const background = new BackgroundTasks({ clock });
+    const targets = new SimEventBridgeFailingTargets(clock, options);
+    return {
+        eventBridge: new SimEventBridge({ background, deliveryTargets: targets }),
+        clock: new SimClockControl({ clock, background }),
+        attempts: targets.attempts,
+        deadLetters: targets.deadLetters,
+    };
+}
+/**
+ * Add a rule with one target carrying the given retry policy and a
+ * dead-letter queue, and put one matching event.
+ */
+export async function putOrder(simulation, target) {
+    const { eventBridge } = simulation;
+    await eventBridge.putRule({
+        input: {
+            Name: "orders",
+            EventPattern: JSON.stringify({ source: ["orders.service"] }),
+        },
+    });
+    await eventBridge.putTargets({
+        input: {
+            Rule: "orders",
+            Targets: [
+                {
+                    Id: "fulfilment",
+                    Arn: "arn:aws:sqs:us-east-1:888888888888:fulfilment",
+                    ...target,
+                },
+            ],
+        },
+    });
+    await eventBridge.putEvents({
+        input: {
+            Entries: [
+                {
+                    Source: "orders.service",
+                    DetailType: "OrderPlaced",
+                    Detail: JSON.stringify({ orderId: "order-1" }),
+                },
+            ],
+        },
+    });
+    await simulation.clock.advanceBy({ milliseconds: 0 });
+}

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

@@ -37,6 +37,28 @@ export interface SimEventBridgeDeliveryTargets {
      * EventBridge.
      */
     deliver(request: SimEventBridgeDeliveryRequest): Promise<void>;
+    /**
+     * Send an event EventBridge gave up delivering to its target's dead-letter
+     * queue, refusing if the queue does not admit EventBridge.
+     */
+    deadLetter(request: SimEventBridgeDeadLetterRequest): Promise<void>;
+}
+/**
+ * Which of a target's retry limits ran out, as the dead-letter message's
+ * `EXHAUSTED_RETRY_CONDITION` names it.
+ */
+export type SimEventBridgeExhaustedRetryCondition = "MaximumEventAgeInSeconds" | "MaximumRetryAttempts";
+/**
+ * One event on its way to a target's dead-letter queue, and why.
+ *
+ * A failure EventBridge does not retry, such as a target that is missing or
+ * refuses EventBridge, carries no exhausted condition.
+ */
+export interface SimEventBridgeDeadLetterRequest {
+    readonly delivery: SimEventBridgeDeliveryRequest;
+    readonly error: unknown;
+    readonly retryAttempts: number;
+    readonly exhaustedCondition: SimEventBridgeExhaustedRetryCondition | undefined;
 }
 /**
  * What a target's policy is asked about, as IAM condition values.

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

@@ -0,0 +1,23 @@
+import type { SimClock } from "../../../util/clock/sim-clock.js";
+import type { SimEventBridgeDeadLetterRequest, SimEventBridgeDeliveryTargets } from "./sim-event-bridge-delivery.js";
+/**
+ * How a set of failing targets behaves.
+ */
+export interface SimEventBridgeFailingTargetsOptions {
+    readonly succeedsOnAttempt?: number;
+    readonly error?: Error;
+    readonly deadLetterRefused?: boolean;
+}
+/**
+ * Targets that fail with an error until a given attempt, and whose
+ * dead-letter queue takes or refuses what it is sent, keeping both.
+ */
+export declare class SimEventBridgeFailingTargets implements SimEventBridgeDeliveryTargets {
+    private readonly clock;
+    private readonly options;
+    readonly attempts: Date[];
+    readonly deadLetters: SimEventBridgeDeadLetterRequest[];
+    constructor(clock: SimClock, options: SimEventBridgeFailingTargetsOptions);
+    deliver(): Promise<void>;
+    deadLetter(request: SimEventBridgeDeadLetterRequest): Promise<void>;
+}

package/dist/service/eventbridge/delivery/sim-event-bridge-failing-targets.test-support.js

@@ -0,0 +1,28 @@
+/**
+ * Targets that fail with an error until a given attempt, and whose
+ * dead-letter queue takes or refuses what it is sent, keeping both.
+ */
+export class SimEventBridgeFailingTargets {
+    clock;
+    options;
+    attempts = [];
+    deadLetters = [];
+    constructor(clock, options) {
+        this.clock = clock;
+        this.options = options;
+    }
+    deliver() {
+        this.attempts.push(this.clock.now());
+        if (this.attempts.length === this.options.succeedsOnAttempt) {
+            return Promise.resolve();
+        }
+        return Promise.reject(this.options.error ?? new Error("fulfilment is unavailable"));
+    }
+    deadLetter(request) {
+        if (this.options.deadLetterRefused === true) {
+            return Promise.reject(new Error("dead-letter queue refused"));
+        }
+        this.deadLetters.push(request);
+        return Promise.resolve();
+    }
+}

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

@@ -1,4 +1,4 @@
-import type { SimEventBridgeDeliveryRequest, SimEventBridgeDeliveryTargets } from "./sim-event-bridge-delivery.js";
+import type { SimEventBridgeDeadLetterRequest, SimEventBridgeDeliveryRequest, SimEventBridgeDeliveryTargets } from "./sim-event-bridge-delivery.js";
 /**
  * The targets of a simulated EventBridge built on its own, which are none.
  *
@@ -13,4 +13,8 @@ export declare class SimEventBridgeNoDeliveryTargets implements SimEventBridgeDe
      * Refuse the delivery, saying why there was nowhere to make it.
      */
     deliver(request: SimEventBridgeDeliveryRequest): Promise<void>;
+    /**
+     * Refuse the dead letter, saying why there was nowhere to send it.
+     */
+    deadLetter(request: SimEventBridgeDeadLetterRequest): Promise<void>;
 }

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

@@ -17,4 +17,13 @@ export class SimEventBridgeNoDeliveryTargets {
             `${request.target.arn.value} was not reached. Reach EventBridge ` +
             `through SimAws for a rule that delivers.`));
     }
+    /**
+     * Refuse the dead letter, saying why there was nowhere to send it.
+     */
+    deadLetter(request) {
+        return Promise.reject(new SimEventBridgeTargetNotFound(`This simulated EventBridge has no queues to send dead letters to, ` +
+            `so the dead-letter queue of target ${request.delivery.target.id} ` +
+            `was not reached. Reach EventBridge through SimAws for a ` +
+            `dead-letter queue that receives.`));
+    }
 }

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

@@ -0,0 +1,28 @@
+import type { SimAwsAccountRegionContainer } from "../../aws/sim-aws-account-region-scope.js";
+import { type SimEventBridgeDeliverySource } from "./sim-event-bridge-delivery.js";
+/**
+ * One SQS message attribute, as SendMessage takes it.
+ */
+export interface SimEventBridgeStringAttribute {
+    readonly DataType: string;
+    readonly StringValue: string;
+}
+/**
+ * One message EventBridge sends to a queue, and the queue it is for.
+ */
+export interface SimEventBridgeQueueMessage {
+    readonly queueName: string;
+    readonly queueArn: string;
+    readonly body: string;
+    readonly attributes?: Readonly<Record<string, SimEventBridgeStringAttribute>>;
+    readonly source: SimEventBridgeDeliverySource;
+}
+/**
+ * Send a message to a queue as EventBridge, if the queue admits it for the
+ * rule.
+ *
+ * A target queue and a dead-letter queue are reached the same way. Both are
+ * sent to as `events.amazonaws.com`, and both need the queue policy to admit
+ * that principal for the rule.
+ */
+export declare function sendEventBridgeQueueMessage(scope: SimAwsAccountRegionContainer, message: SimEventBridgeQueueMessage): Promise<void>;

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

@@ -0,0 +1,45 @@
+import { simScopeIamAuthZ } from "../../iam/authorize/sim-iam-region-auth-z.js";
+import { SimSqsServiceSendAuthorizer } from "../../sqs/command/authorize/sim-sqs-service-send-authorizer.js";
+import { SimEventBridgeDeliveryNotPermitted, SimEventBridgeTargetNotFound, } from "../error/sim-event-bridge-delivery.error.js";
+import { simEventBridgeServicePrincipal, } from "./sim-event-bridge-delivery.js";
+/**
+ * Send a message to a queue as EventBridge, if the queue admits it for the
+ * rule.
+ *
+ * A target queue and a dead-letter queue are reached the same way. Both are
+ * sent to as `events.amazonaws.com`, and both need the queue policy to admit
+ * that principal for the rule.
+ */
+export async function sendEventBridgeQueueMessage(scope, message) {
+    const { queueArn, source } = message;
+    const queue = scope.sqs().findQueue(message.queueName);
+    if (queue === undefined) {
+        throw new SimEventBridgeTargetNotFound(`${queueArn} is not a simulated SQS queue.`);
+    }
+    const decision = new SimSqsServiceSendAuthorizer({
+        iam: simScopeIamAuthZ(scope),
+    }).authorize({
+        queue,
+        servicePrincipal: simEventBridgeServicePrincipal,
+        ...source,
+    });
+    if (decision.isDenied) {
+        throw new SimEventBridgeDeliveryNotPermitted(`The queue policy of ${queueArn} 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 scope.sqs().sendMessage({
+        input: {
+            QueueUrl: queue.arn.url,
+            MessageBody: message.body,
+            MessageAttributes: message.attributes,
+        },
+    }, {
+        caller: { kind: "service", service: simEventBridgeServicePrincipal },
+        ...source,
+    });
+}

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

@@ -1,10 +1,12 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
 import type { SimEventBridgeDeliveryRequest, SimEventBridgeDeliveryTargets } from "./sim-event-bridge-delivery.js";
 import type { SimEventBridgeDeliveryFailure } from "./sim-event-bridge-delivery-failures.js";
 interface SimEventBridgeTargetDeliveryProperties {
     readonly endpoints: SimEventBridgeDeliveryTargets;
+    readonly background: BackgroundScheduler;
 }
 /**
- * Makes one delivery and keeps whatever went wrong.
+ * Makes one delivery, with its retries, and keeps whatever went wrong.
  *
  * A failure is recorded rather than thrown, because these run as background
  * tasks and one left rejected would fail an unrelated
@@ -14,6 +16,7 @@ interface SimEventBridgeTargetDeliveryProperties {
  */
 export declare class SimEventBridgeTargetDelivery {
     private readonly endpoints;
+    private readonly background;
     private readonly failures;
     constructor(properties: SimEventBridgeTargetDeliveryProperties);
     /**