@kensio/yulin 1.21.26 → 1.21.27

package/dist/service/eventbridge/source/sim-partner-event-source-name.js

@@ -0,0 +1,62 @@
+import { SimEventBridgeValidationException } from "../error/sim-event-bridge.error.js";
+const partnerPrefix = "aws.partner/";
+/**
+ * The characters one segment of a partner event source name may carry.
+ */
+const partnerSegmentPattern = /^[.\-_A-Za-z0-9]+$/;
+/**
+ * Real EventBridge wants the partner's own name and at least one more segment
+ * after the prefix, such as `aws.partner/stripe.com/ed_test`.
+ */
+const minimumPartnerSegments = 2;
+const maximumPartnerEventSourceNameLength = 256;
+const partnerSegmentStart = partnerPrefix.length;
+/**
+ * Whether a string has the shape of a partner event source name.
+ *
+ * A partner event bus takes the name of its source, so this is also the one
+ * shape of bus name that may carry a `/`.
+ */
+export function isPartnerEventSourceName(value) {
+    // Read segment by segment, which is the API's own pattern
+    // `aws\.partner(/[\.\-_A-Za-z0-9]+){2,}` without the nested repetition.
+    const segments = value.slice(partnerSegmentStart).split("/");
+    return (value.length <= maximumPartnerEventSourceNameLength &&
+        value.startsWith(partnerPrefix) &&
+        segments.length >= minimumPartnerSegments &&
+        segments.every((segment) => partnerSegmentPattern.test(segment)));
+}
+/**
+ * The name of one partner event source.
+ *
+ * A SaaS partner names the source when it creates it, in the form
+ * `aws.partner/<partner>/<name>`. The receiving Account never chooses the
+ * name. It creates a bus under the same one.
+ */
+export class SimPartnerEventSourceName {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    /**
+     * Read a partner event source name from request input, refusing one real
+     * EventBridge would refuse.
+     */
+    static of(value, parameterName) {
+        if (!isPartnerEventSourceName(value)) {
+            throw new SimEventBridgeValidationException(`Invalid parameter: ${parameterName} Reason: '${value}' is not a ` +
+                `partner event source name, which takes the form ` +
+                `aws.partner/<partner>/<name> and is at most ` +
+                `${String(maximumPartnerEventSourceNameLength)} characters long.`);
+        }
+        return new this(value);
+    }
+    /**
+     * The partner that created the source, which is the segment after
+     * `aws.partner`.
+     */
+    get partner() {
+        // The pattern guarantees a `/` after the partner segment.
+        return this.value.slice(partnerSegmentStart, this.value.indexOf("/", partnerSegmentStart));
+    }
+}

package/dist/service/eventbridge/source/sim-partner-event-source-store.d.ts

@@ -0,0 +1,18 @@
+import type { SimPartnerEventSource } from "./sim-partner-event-source.js";
+/**
+ * The partner event sources shared with one simulated EventBridge scope.
+ *
+ * Sources are keyed by name. A partner names each one uniquely across every
+ * Account it serves, so a name is enough to find one.
+ */
+export declare class SimPartnerEventSourceStore {
+    private readonly sources;
+    /**
+     * Store a newly created source, refusing a name already taken.
+     */
+    add(source: SimPartnerEventSource): void;
+    /**
+     * Resolve a source by name, or refuse.
+     */
+    require(name: string): SimPartnerEventSource;
+}

package/dist/service/eventbridge/source/sim-partner-event-source-store.js

@@ -0,0 +1,29 @@
+import { SimEventBridgeResourceAlreadyExistsException, SimEventBridgeResourceNotFoundException, } from "../error/sim-event-bridge.error.js";
+/**
+ * The partner event sources shared with one simulated EventBridge scope.
+ *
+ * Sources are keyed by name. A partner names each one uniquely across every
+ * Account it serves, so a name is enough to find one.
+ */
+export class SimPartnerEventSourceStore {
+    sources = new Map();
+    /**
+     * Store a newly created source, refusing a name already taken.
+     */
+    add(source) {
+        if (this.sources.has(source.name.value)) {
+            throw new SimEventBridgeResourceAlreadyExistsException(`Event source ${source.name.value} already exists.`);
+        }
+        this.sources.set(source.name.value, source);
+    }
+    /**
+     * Resolve a source by name, or refuse.
+     */
+    require(name) {
+        const found = this.sources.get(name);
+        if (found === undefined) {
+            throw new SimEventBridgeResourceNotFoundException(`Event source ${name} does not exist.`);
+        }
+        return found;
+    }
+}

package/dist/service/eventbridge/source/sim-partner-event-source.d.ts

@@ -0,0 +1,46 @@
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimPartnerEventSourceName } from "./sim-partner-event-source-name.js";
+/**
+ * The states a partner event source reports.
+ *
+ * `DELETED` is absent. It belongs to a source the partner deleted while its
+ * bus was still there, and nothing here deletes a source.
+ */
+export type SimPartnerEventSourceState = "ACTIVE" | "PENDING";
+/**
+ * The ARN of a partner event source, which a request authorizes against
+ * before the source is looked up.
+ *
+ * The ARN carries no Account. The source is the partner's resource, shared
+ * with the receiving Account, and real EventBridge writes it with an empty
+ * Account field, as the `resources` of a Stripe event show.
+ */
+export declare function partnerEventSourceArn(name: SimPartnerEventSourceName, accountRegionScope: SimAwsAccountRegionScope): string;
+interface SimPartnerEventSourceProperties {
+    readonly name: SimPartnerEventSourceName;
+    readonly accountRegionScope: SimAwsAccountRegionScope;
+    readonly createdAt: Date;
+}
+/**
+ * One partner event source, shared with a receiving Account and Region.
+ *
+ * A SaaS partner creates the source from its own Account, naming the Account
+ * that may receive from it. The receiving Account activates it by creating a
+ * partner event bus under the same name, and the partner's events then land
+ * on that bus.
+ *
+ * The state is worked out from whether that bus exists rather than stored
+ * here. Creating the bus is what activates a source on real AWS, and deleting
+ * the bus puts it back to pending.
+ */
+export declare class SimPartnerEventSource {
+    readonly name: SimPartnerEventSourceName;
+    readonly arn: string;
+    readonly creationTime: Date;
+    constructor(properties: SimPartnerEventSourceProperties);
+    /**
+     * The source's state, given whether a bus of its name exists.
+     */
+    state(hasBus: boolean): SimPartnerEventSourceState;
+}
+export {};

package/dist/service/eventbridge/source/sim-partner-event-source.js

@@ -0,0 +1,43 @@
+/**
+ * The ARN of a partner event source, which a request authorizes against
+ * before the source is looked up.
+ *
+ * The ARN carries no Account. The source is the partner's resource, shared
+ * with the receiving Account, and real EventBridge writes it with an empty
+ * Account field, as the `resources` of a Stripe event show.
+ */
+export function partnerEventSourceArn(name, accountRegionScope) {
+    return `arn:aws:events:${accountRegionScope.regionName}::event-source/${name.value}`;
+}
+/**
+ * One partner event source, shared with a receiving Account and Region.
+ *
+ * A SaaS partner creates the source from its own Account, naming the Account
+ * that may receive from it. The receiving Account activates it by creating a
+ * partner event bus under the same name, and the partner's events then land
+ * on that bus.
+ *
+ * The state is worked out from whether that bus exists rather than stored
+ * here. Creating the bus is what activates a source on real AWS, and deleting
+ * the bus puts it back to pending.
+ */
+export class SimPartnerEventSource {
+    name;
+    arn;
+    creationTime;
+    constructor(properties) {
+        const { name, accountRegionScope } = properties;
+        this.name = name;
+        this.arn = partnerEventSourceArn(name, accountRegionScope);
+        this.creationTime = properties.createdAt;
+    }
+    /**
+     * The source's state, given whether a bus of its name exists.
+     */
+    state(hasBus) {
+        if (hasBus) {
+            return "ACTIVE";
+        }
+        return "PENDING";
+    }
+}

package/dist/service/eventbridge/target/sim-event-target-dead-letter-config.d.ts

@@ -0,0 +1,28 @@
+import { type SimSqsQueueLocation } from "../../sqs/queue/sim-sqs-queue-arn.js";
+/**
+ * A target's `DeadLetterConfig`, as a request or a template carries it.
+ */
+export interface SimEventTargetDeadLetterConfigInput {
+    readonly Arn?: string | undefined;
+}
+/**
+ * The standard SQS queue a target sends an event to once EventBridge gives up
+ * delivering it.
+ */
+export declare class SimEventTargetDeadLetterConfig {
+    readonly declared: SimEventTargetDeadLetterConfigInput;
+    readonly arn: string;
+    readonly queue: SimSqsQueueLocation;
+    private constructor();
+    /**
+     * Read the dead-letter configuration a target may leave out.
+     */
+    static optional(config: SimEventTargetDeadLetterConfigInput | undefined): SimEventTargetDeadLetterConfig | undefined;
+    /**
+     * Read a dead-letter configuration, refusing anything but a standard queue.
+     *
+     * Real EventBridge takes only a standard queue here. A FIFO queue is refused
+     * by its name, which always ends `.fifo`.
+     */
+    static of(config: SimEventTargetDeadLetterConfigInput): SimEventTargetDeadLetterConfig;
+}

package/dist/service/eventbridge/target/sim-event-target-dead-letter-config.js

@@ -0,0 +1,42 @@
+import { parseSqsQueueArn, } from "../../sqs/queue/sim-sqs-queue-arn.js";
+import { SimEventBridgeValidationException } from "../error/sim-event-bridge.error.js";
+const fifoQueueSuffix = ".fifo";
+/**
+ * The standard SQS queue a target sends an event to once EventBridge gives up
+ * delivering it.
+ */
+export class SimEventTargetDeadLetterConfig {
+    declared;
+    arn;
+    queue;
+    constructor(declared, arn, queue) {
+        this.declared = { ...declared };
+        this.arn = arn;
+        this.queue = queue;
+    }
+    /**
+     * Read the dead-letter configuration a target may leave out.
+     */
+    static optional(config) {
+        if (config === undefined) {
+            return undefined;
+        }
+        return this.of(config);
+    }
+    /**
+     * Read a dead-letter configuration, refusing anything but a standard queue.
+     *
+     * Real EventBridge takes only a standard queue here. A FIFO queue is refused
+     * by its name, which always ends `.fifo`.
+     */
+    static of(config) {
+        const arn = config.Arn ?? "";
+        const queue = parseSqsQueueArn(arn);
+        if (queue === undefined || queue.name.endsWith(fifoQueueSuffix)) {
+            throw new SimEventBridgeValidationException(`Invalid parameter: Target DeadLetterConfig Arn Reason: '${arn}' is ` +
+                `not a standard SQS queue ARN. One is ` +
+                `arn:aws:sqs:<region>:<account-id>:<queue-name>.`);
+        }
+        return new this(config, arn, queue);
+    }
+}

package/dist/service/eventbridge/target/sim-event-target-retry-policy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A target's `RetryPolicy`, as a request or a template carries it.
+ */
+export interface SimEventTargetRetryPolicyInput {
+    readonly MaximumEventAgeInSeconds?: number | undefined;
+    readonly MaximumRetryAttempts?: number | undefined;
+}
+/**
+ * The retry limits one target declares, and the values they come to.
+ *
+ * A limit the policy leaves out takes EventBridge's own default, which is 185
+ * retries over at most 24 hours.
+ */
+export declare class SimEventTargetRetryPolicy {
+    readonly declared: SimEventTargetRetryPolicyInput;
+    readonly maximumEventAgeInSeconds: number;
+    readonly maximumRetryAttempts: number;
+    private constructor();
+    /**
+     * Read the retry policy a target may leave out.
+     */
+    static optional(policy: SimEventTargetRetryPolicyInput | undefined): SimEventTargetRetryPolicy | undefined;
+    /**
+     * Read a retry policy, refusing values outside EventBridge's ranges.
+     */
+    static of(policy: SimEventTargetRetryPolicyInput): SimEventTargetRetryPolicy;
+    private static requireWholeNumber;
+}

package/dist/service/eventbridge/target/sim-event-target-retry-policy.js

@@ -0,0 +1,53 @@
+import { SimEventBridgeValidationException } from "../error/sim-event-bridge.error.js";
+/**
+ * The longest EventBridge keeps retrying an event, and the most retries it
+ * makes, when a target's retry policy leaves either out.
+ */
+const defaultMaximumEventAgeInSeconds = 86_400;
+const defaultMaximumRetryAttempts = 185;
+const minimumEventAgeInSeconds = 60;
+/**
+ * The retry limits one target declares, and the values they come to.
+ *
+ * A limit the policy leaves out takes EventBridge's own default, which is 185
+ * retries over at most 24 hours.
+ */
+export class SimEventTargetRetryPolicy {
+    declared;
+    maximumEventAgeInSeconds;
+    maximumRetryAttempts;
+    constructor(policy) {
+        this.declared = { ...policy };
+        this.maximumEventAgeInSeconds =
+            policy.MaximumEventAgeInSeconds ?? defaultMaximumEventAgeInSeconds;
+        this.maximumRetryAttempts =
+            policy.MaximumRetryAttempts ?? defaultMaximumRetryAttempts;
+    }
+    /**
+     * Read the retry policy a target may leave out.
+     */
+    static optional(policy) {
+        if (policy === undefined) {
+            return undefined;
+        }
+        return this.of(policy);
+    }
+    /**
+     * Read a retry policy, refusing values outside EventBridge's ranges.
+     */
+    static of(policy) {
+        this.requireWholeNumber("MaximumEventAgeInSeconds", policy.MaximumEventAgeInSeconds, minimumEventAgeInSeconds, defaultMaximumEventAgeInSeconds);
+        this.requireWholeNumber("MaximumRetryAttempts", policy.MaximumRetryAttempts, 0, defaultMaximumRetryAttempts);
+        return new this(policy);
+    }
+    static requireWholeNumber(name, value, minimum, maximum) {
+        if (value === undefined) {
+            return;
+        }
+        if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+            throw new SimEventBridgeValidationException(`Invalid parameter: Target RetryPolicy ${name} Reason: it is a whole ` +
+                `number between ${String(minimum)} and ${String(maximum)}, and ` +
+                `${String(value)} is not.`);
+        }
+    }
+}

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

@@ -1,4 +1,6 @@
 import { SimEventTargetArn } from "./sim-event-target-arn.js";
+import { SimEventTargetDeadLetterConfig, type SimEventTargetDeadLetterConfigInput } from "./sim-event-target-dead-letter-config.js";
+import { SimEventTargetRetryPolicy, type SimEventTargetRetryPolicyInput } from "./sim-event-target-retry-policy.js";
 import { SimEventTargetEcs, type SimEventTargetTaskProperties } from "./sim-event-target-ecs.js";
 /**
  * One place a rule sends the events it matches.
@@ -29,6 +31,19 @@ export declare class SimEventTarget {
      * is what the task overrides instead.
      */
     readonly ecs: SimEventTargetEcs | undefined;
+    /**
+     * How long and how often a failed delivery is retried, where the target
+     * says.
+     *
+     * A target without one is delivered once. Real EventBridge retries such a
+     * target for up to 24 hours by default, and that divergence is documented.
+     */
+    readonly retryPolicy: SimEventTargetRetryPolicy | undefined;
+    /**
+     * The queue an event goes to once delivery is given up, where the target
+     * names one.
+     */
+    readonly deadLetterConfig: SimEventTargetDeadLetterConfig | undefined;
     private constructor();
     /**
      * Read a target from request input.
@@ -36,6 +51,8 @@ export declare class SimEventTarget {
     static of(properties: SimEventTargetTaskProperties & {
         readonly Id?: string | undefined;
         readonly Arn?: string | undefined;
+        readonly RetryPolicy?: SimEventTargetRetryPolicyInput | undefined;
+        readonly DeadLetterConfig?: SimEventTargetDeadLetterConfigInput | undefined;
     }): SimEventTarget;
     /**
      * Read a target's fixed input, which has to be JSON.

package/dist/service/eventbridge/target/sim-event-target.js

@@ -1,5 +1,7 @@
 import { SimEventBridgeValidationException } from "../error/sim-event-bridge.error.js";
 import { SimEventTargetArn } from "./sim-event-target-arn.js";
+import { SimEventTargetDeadLetterConfig, } from "./sim-event-target-dead-letter-config.js";
+import { SimEventTargetRetryPolicy, } from "./sim-event-target-retry-policy.js";
 import { SimEventTargetEcs, } from "./sim-event-target-ecs.js";
 /**
  * Real EventBridge allows alphanumerics, full stops, hyphens and underscores,
@@ -35,11 +37,26 @@ export class SimEventTarget {
      * is what the task overrides instead.
      */
     ecs;
+    /**
+     * How long and how often a failed delivery is retried, where the target
+     * says.
+     *
+     * A target without one is delivered once. Real EventBridge retries such a
+     * target for up to 24 hours by default, and that divergence is documented.
+     */
+    retryPolicy;
+    /**
+     * The queue an event goes to once delivery is given up, where the target
+     * names one.
+     */
+    deadLetterConfig;
     constructor(properties) {
         this.id = properties.id;
         this.arn = properties.arn;
         this.input = properties.input;
         this.ecs = properties.ecs;
+        this.retryPolicy = properties.retryPolicy;
+        this.deadLetterConfig = properties.deadLetterConfig;
     }
     /**
      * Read a target from request input.
@@ -51,6 +68,8 @@ export class SimEventTarget {
             arn,
             input: this.readInput(properties.Input),
             ecs: SimEventTargetEcs.of(arn, properties),
+            retryPolicy: SimEventTargetRetryPolicy.optional(properties.RetryPolicy),
+            deadLetterConfig: SimEventTargetDeadLetterConfig.optional(properties.DeadLetterConfig),
         });
     }
     /**