@kensio/yulin 1.11.1 → 1.12.1

package/dist/service/eventbridge/pattern/sim-event-pattern-node.js

@@ -0,0 +1,81 @@
+import { isRecord } from "../../../util/type-guard/record.js";
+import { SimEventPatternField } from "./sim-event-pattern-field.js";
+import { eventPatternRefusal, unsimulatedOperatorRefusal, } from "./sim-event-pattern-refusals.js";
+/**
+ * The key real EventBridge matches several fields with, one of which is enough.
+ *
+ * It appears where a field name would, rather than inside a condition list, so
+ * it is refused here rather than by the operator table.
+ */
+const orKey = "$or";
+/**
+ * One object in a pattern, and the keys it puts conditions on.
+ *
+ * A pattern has the same shape as the events it matches, so a nested object in
+ * the pattern is a pattern for the nested object in the event. Every key has
+ * to match, and the event may carry keys the pattern says nothing about.
+ */
+export class SimEventPatternNode {
+    entries;
+    constructor(entries) {
+        this.entries = entries;
+    }
+    /**
+     * Read one object of a pattern.
+     */
+    static of(written) {
+        const writtenEntries = Object.entries(written);
+        if (writtenEntries.length === 0) {
+            throw eventPatternRefusal("a pattern object puts no conditions on anything");
+        }
+        const entries = new Map();
+        for (const [key, value] of writtenEntries) {
+            entries.set(key, this.entryFor(key, value));
+        }
+        return new this(entries);
+    }
+    /**
+     * Whether one key of the pattern holds for the object the event carries.
+     */
+    static holds(entry, carried, key) {
+        if (!carried.has(key)) {
+            return entry instanceof SimEventPatternField && entry.matchesAbsent();
+        }
+        return entry.matches(carried.get(key) ?? null);
+    }
+    /**
+     * Read what a pattern says about one key.
+     */
+    static entryFor(key, written) {
+        if (key === orKey) {
+            throw unsimulatedOperatorRefusal(orKey);
+        }
+        if (Array.isArray(written)) {
+            return SimEventPatternField.of(written, key);
+        }
+        if (isRecord(written)) {
+            return this.of(written);
+        }
+        throw eventPatternRefusal(`${key} is written as ${JSON.stringify(written)}, and a pattern key ` +
+            `takes either a list of match conditions or a nested pattern object`);
+    }
+    /**
+     * Whether an event value satisfies every key of this pattern object.
+     *
+     * A value that is not an object satisfies nothing, since there is nothing to
+     * read the keys out of.
+     */
+    matches(value) {
+        if (!isRecord(value)) {
+            return false;
+        }
+        // Read into a Map so a key the event does not have is told apart from one
+        // it carries as undefined, without indexing the object by a key the
+        // pattern supplied.
+        const carried = new Map(Object.entries(value));
+        return this.entries
+            .entries()
+            .every(([key, entry]) => SimEventPatternNode.holds(entry, carried, key));
+    }
+}
+//# sourceMappingURL=sim-event-pattern-node.js.map

package/dist/service/eventbridge/pattern/sim-event-pattern-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-event-pattern-node.js","sourceRoot":"","sources":["../../../../src/service/eventbridge/pattern/sim-event-pattern-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAE9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EACL,mBAAmB,EACnB,0BAA0B,GAC3B,MAAM,iCAAiC,CAAC;AAEzC;;;;;GAKG;AACH,MAAM,KAAK,GAAG,KAAK,CAAC;AAQpB;;;;;;GAMG;AACH,MAAM,OAAO,mBAAmB;IACb,OAAO,CAA4C;IAEpE,YAAoB,OAAkD;QACpE,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,OAAkC;QAC1C,MAAM,cAAc,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAE/C,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAChC,MAAM,mBAAmB,CACvB,iDAAiD,CAClD,CAAC;QACJ,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,GAAG,EAAgC,CAAC;QAExD,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,cAAc,EAAE,CAAC;YAC1C,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;QAC9C,CAAC;QAED,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,KAAK,CAClB,KAA2B,EAC3B,OAAqC,EACrC,GAAW;QAEX,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACtB,OAAO,KAAK,YAAY,oBAAoB,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;QACxE,CAAC;QAED,OAAO,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,CAAC;IACjD,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,QAAQ,CACrB,GAAW,EACX,OAAkB;QAElB,IAAI,GAAG,KAAK,KAAK,EAAE,CAAC;YAClB,MAAM,0BAA0B,CAAC,KAAK,CAAC,CAAC;QAC1C,CAAC;QAED,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3B,OAAO,oBAAoB,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;QAC/C,CAAC;QAED,IAAI,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YACtB,OAAO,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC;QAC1B,CAAC;QAED,MAAM,mBAAmB,CACvB,GAAG,GAAG,kBAAkB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,sBAAsB;YACnE,oEAAoE,CACvE,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,OAAO,CAAC,KAAc;QACpB,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACrB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,0EAA0E;QAC1E,oEAAoE;QACpE,oBAAoB;QACpB,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;QAE/C,OAAO,IAAI,CAAC,OAAO;aAChB,OAAO,EAAE;aACT,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC;IAC7E,CAAC;CACF"}

package/dist/service/eventbridge/pattern/sim-event-pattern-operators.d.ts

@@ -0,0 +1,11 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimEventPatternMatch } from "./match/sim-event-pattern-match.js";
+/**
+ * Read the one operator a condition object is written with.
+ *
+ * A condition is a single-key object, such as `{"prefix": "us-"}`. Two keys is
+ * not a condition real EventBridge has, so it is refused rather than one of
+ * them being picked.
+ */
+export declare function readPatternCondition(condition: Record<string, JSONValue>): SimEventPatternMatch;
+//# sourceMappingURL=sim-event-pattern-operators.d.ts.map

package/dist/service/eventbridge/pattern/sim-event-pattern-operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-event-pattern-operators.d.ts","sourceRoot":"","sources":["../../../../src/service/eventbridge/pattern/sim-event-pattern-operators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAkBlE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAyD/E;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GACnC,oBAAoB,CA0BtB"}

package/dist/service/eventbridge/pattern/sim-event-pattern-operators.js

@@ -0,0 +1,69 @@
+import { eventPatternAnythingButOperator, SimEventAnythingButMatch, } from "./match/sim-event-anything-but-match.js";
+import { eventPatternPrefixOperator, eventPatternSuffixOperator, SimEventAffixMatch, } from "./match/sim-event-affix-match.js";
+import { eventPatternExistsOperator, SimEventExistsMatch, } from "./match/sim-event-exists-match.js";
+import { eventPatternNumericOperator, SimEventNumericMatch, } from "./match/sim-event-numeric-match.js";
+import { eventPatternRefusal, unsimulatedOperatorRefusal, } from "./sim-event-pattern-refusals.js";
+/**
+ * Every operator a condition can be written with here.
+ */
+const operators = new Map([
+    [
+        eventPatternPrefixOperator,
+        (operand) => SimEventAffixMatch.prefix(operand),
+    ],
+    [
+        eventPatternSuffixOperator,
+        (operand) => SimEventAffixMatch.suffix(operand),
+    ],
+    [
+        eventPatternAnythingButOperator,
+        (operand) => SimEventAnythingButMatch.of(operand),
+    ],
+    [
+        eventPatternNumericOperator,
+        (operand) => SimEventNumericMatch.of(operand),
+    ],
+    [
+        eventPatternExistsOperator,
+        (operand) => SimEventExistsMatch.of(operand),
+    ],
+]);
+/**
+ * The operators real EventBridge has that this simulation does not evaluate.
+ *
+ * Held by name so a pattern using one is refused with the name in the message,
+ * rather than refused as an unrecognised condition. Which of the two a reader
+ * gets tells them whether they mistyped an operator or reached for one that is
+ * not here yet.
+ */
+const unsimulatedOperators = new Set([
+    "cidr",
+    "equals-ignore-case",
+    "wildcard",
+    "$or",
+]);
+/**
+ * Read the one operator a condition object is written with.
+ *
+ * A condition is a single-key object, such as `{"prefix": "us-"}`. Two keys is
+ * not a condition real EventBridge has, so it is refused rather than one of
+ * them being picked.
+ */
+export function readPatternCondition(condition) {
+    const written = Object.entries(condition);
+    const [only] = written;
+    if (only === undefined || written.length !== 1) {
+        throw eventPatternRefusal(`a match condition is written with one operator, and this one is ` +
+            `written with ${String(written.length)}`);
+    }
+    const [name, operand] = only;
+    if (unsimulatedOperators.has(name)) {
+        throw unsimulatedOperatorRefusal(name);
+    }
+    const read = operators.get(name);
+    if (read === undefined) {
+        throw eventPatternRefusal(`${name} is not an operator EventBridge event patterns have`);
+    }
+    return read(operand);
+}
+//# sourceMappingURL=sim-event-pattern-operators.js.map

package/dist/service/eventbridge/pattern/sim-event-pattern-operators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-event-pattern-operators.js","sourceRoot":"","sources":["../../../../src/service/eventbridge/pattern/sim-event-pattern-operators.ts"],"names":[],"mappings":"AACA,OAAO,EACL,+BAA+B,EAC/B,wBAAwB,GACzB,MAAM,yCAAyC,CAAC;AACjD,OAAO,EACL,0BAA0B,EAC1B,0BAA0B,EAC1B,kBAAkB,GACnB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACL,0BAA0B,EAC1B,mBAAmB,GACpB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,2BAA2B,EAC3B,oBAAoB,GACrB,MAAM,oCAAoC,CAAC;AAE5C,OAAO,EACL,mBAAmB,EACnB,0BAA0B,GAC3B,MAAM,iCAAiC,CAAC;AASzC;;GAEG;AACH,MAAM,SAAS,GAAuD,IAAI,GAAG,CAG3E;IACA;QACE,0BAA0B;QAC1B,CAAC,OAAO,EAAwB,EAAE,CAAC,kBAAkB,CAAC,MAAM,CAAC,OAAO,CAAC;KACtE;IACD;QACE,0BAA0B;QAC1B,CAAC,OAAO,EAAwB,EAAE,CAAC,kBAAkB,CAAC,MAAM,CAAC,OAAO,CAAC;KACtE;IACD;QACE,+BAA+B;QAC/B,CAAC,OAAO,EAAwB,EAAE,CAAC,wBAAwB,CAAC,EAAE,CAAC,OAAO,CAAC;KACxE;IACD;QACE,2BAA2B;QAC3B,CAAC,OAAO,EAAwB,EAAE,CAAC,oBAAoB,CAAC,EAAE,CAAC,OAAO,CAAC;KACpE;IACD;QACE,0BAA0B;QAC1B,CAAC,OAAO,EAAwB,EAAE,CAAC,mBAAmB,CAAC,EAAE,CAAC,OAAO,CAAC;KACnE;CACF,CAAC,CAAC;AAEH;;;;;;;GAOG;AACH,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAAC;IACnC,MAAM;IACN,oBAAoB;IACpB,UAAU;IACV,KAAK;CACN,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAClC,SAAoC;IAEpC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAC1C,MAAM,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC;IAEvB,IAAI,IAAI,KAAK,SAAS,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC/C,MAAM,mBAAmB,CACvB,kEAAkE;YAChE,gBAAgB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAC3C,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAE7B,IAAI,oBAAoB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QACnC,MAAM,0BAA0B,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IAED,MAAM,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAEjC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,MAAM,mBAAmB,CACvB,GAAG,IAAI,qDAAqD,CAC7D,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC;AACvB,CAAC"}

package/dist/service/eventbridge/pattern/sim-event-pattern-refusals.d.ts

@@ -0,0 +1,24 @@
+import { SimEventBridgeInvalidEventPatternException } from "../error/sim-event-bridge.error.js";
+import type { JSONValue } from "../../../util/type-guard/json.js";
+/**
+ * Refuse a pattern, in the shape real EventBridge words its refusals.
+ */
+export declare function eventPatternRefusal(reason: string): SimEventBridgeInvalidEventPatternException;
+/**
+ * Refuse an operator real EventBridge has and this simulation does not.
+ *
+ * Named rather than ignored, and refused rather than left never matching. A
+ * pattern using `wildcard` that quietly matched nothing would look like a
+ * pattern that was simply too specific, and the rule would go unnoticed until
+ * the deployment.
+ */
+export declare function unsimulatedOperatorRefusal(operator: string): SimEventBridgeInvalidEventPatternException;
+/**
+ * Read the operand of a condition as the list it has to be.
+ */
+export declare function patternList(operand: JSONValue, operator: string): readonly JSONValue[];
+/**
+ * Read the operand of a condition as the string it has to be.
+ */
+export declare function patternString(operand: JSONValue, operator: string): string;
+//# sourceMappingURL=sim-event-pattern-refusals.d.ts.map

package/dist/service/eventbridge/pattern/sim-event-pattern-refusals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-event-pattern-refusals.d.ts","sourceRoot":"","sources":["../../../../src/service/eventbridge/pattern/sim-event-pattern-refusals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0CAA0C,EAAE,MAAM,oCAAoC,CAAC;AAChG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAElE;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,GACb,0CAA0C,CAE5C;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,GACf,0CAA0C,CAM5C;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,SAAS,EAClB,QAAQ,EAAE,MAAM,GACf,SAAS,SAAS,EAAE,CAUtB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAS1E"}

package/dist/service/eventbridge/pattern/sim-event-pattern-refusals.js

@@ -0,0 +1,40 @@
+import { SimEventBridgeInvalidEventPatternException } from "../error/sim-event-bridge.error.js";
+/**
+ * Refuse a pattern, in the shape real EventBridge words its refusals.
+ */
+export function eventPatternRefusal(reason) {
+    return new SimEventBridgeInvalidEventPatternException(reason);
+}
+/**
+ * Refuse an operator real EventBridge has and this simulation does not.
+ *
+ * Named rather than ignored, and refused rather than left never matching. A
+ * pattern using `wildcard` that quietly matched nothing would look like a
+ * pattern that was simply too specific, and the rule would go unnoticed until
+ * the deployment.
+ */
+export function unsimulatedOperatorRefusal(operator) {
+    return eventPatternRefusal(`the ${operator} operator is not simulated, so this pattern cannot be ` +
+        `evaluated. Simulated EventBridge supports exact values, prefix, ` +
+        `suffix, anything-but, numeric and exists.`);
+}
+/**
+ * Read the operand of a condition as the list it has to be.
+ */
+export function patternList(operand, operator) {
+    if (!Array.isArray(operand)) {
+        throw eventPatternRefusal(`${operator} match takes a list, and this one takes ${JSON.stringify(operand)}`);
+    }
+    return operand;
+}
+/**
+ * Read the operand of a condition as the string it has to be.
+ */
+export function patternString(operand, operator) {
+    if (typeof operand !== "string") {
+        throw eventPatternRefusal(`${operator} match compares against a string, and this one compares ` +
+            `against ${JSON.stringify(operand)}`);
+    }
+    return operand;
+}
+//# sourceMappingURL=sim-event-pattern-refusals.js.map

package/dist/service/eventbridge/pattern/sim-event-pattern-refusals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-event-pattern-refusals.js","sourceRoot":"","sources":["../../../../src/service/eventbridge/pattern/sim-event-pattern-refusals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0CAA0C,EAAE,MAAM,oCAAoC,CAAC;AAGhG;;GAEG;AACH,MAAM,UAAU,mBAAmB,CACjC,MAAc;IAEd,OAAO,IAAI,0CAA0C,CAAC,MAAM,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,0BAA0B,CACxC,QAAgB;IAEhB,OAAO,mBAAmB,CACxB,OAAO,QAAQ,wDAAwD;QACrE,kEAAkE;QAClE,2CAA2C,CAC9C,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CACzB,OAAkB,EAClB,QAAgB;IAEhB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QAC5B,MAAM,mBAAmB,CACvB,GAAG,QAAQ,2CAA2C,IAAI,CAAC,SAAS,CAClE,OAAO,CACR,EAAE,CACJ,CAAC;IACJ,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,OAAkB,EAAE,QAAgB;IAChE,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;QAChC,MAAM,mBAAmB,CACvB,GAAG,QAAQ,0DAA0D;YACnE,WAAW,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CACvC,CAAC;IACJ,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}

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

@@ -0,0 +1,35 @@
+import type { SimEventBridgeEnvelope } from "../event/sim-event-bridge-event.js";
+/**
+ * One rule's event pattern.
+ *
+ * A pattern has the same shape as the events it matches: a key in the pattern
+ * names a field of the event, and a nested object in the pattern is a pattern
+ * for the nested object in the event. Every key has to match, so a pattern
+ * with more keys matches fewer events.
+ *
+ * The string it was written as is kept, because DescribeRule reports the
+ * pattern back and a caller comparing it against what they sent should see
+ * what they sent rather than a re-serialised version of it.
+ */
+export declare class SimEventPattern {
+    readonly source: string;
+    private readonly root;
+    private constructor();
+    /**
+     * Read a pattern from the JSON a request carries.
+     */
+    static of(source: string): SimEventPattern;
+    /**
+     * Read the pattern JSON, refusing anything that is not a JSON object.
+     */
+    private static parse;
+    /**
+     * Whether an event matches this pattern.
+     *
+     * An event a bus received arrives as its envelope, and one a caller handed
+     * to TestEventPattern arrives as the object their JSON parsed to. Both are
+     * read the same way: by key, from the top down.
+     */
+    matches(event: SimEventBridgeEnvelope | Record<string, unknown>): boolean;
+}
+//# sourceMappingURL=sim-event-pattern.d.ts.map

package/dist/service/eventbridge/pattern/sim-event-pattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-event-pattern.d.ts","sourceRoot":"","sources":["../../../../src/service/eventbridge/pattern/sim-event-pattern.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AASjF;;;;;;;;;;;GAWG;AACH,qBAAa,eAAe;IAC1B,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAsB;IAE3C,OAAO,eAGN;IAED;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CASzC;IAED;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,KAAK;IAkBpB;;;;;;OAMG;IACH,OAAO,CAAC,KAAK,EAAE,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAExE;CACF"}

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

@@ -0,0 +1,64 @@
+import { isRecord } from "../../../util/type-guard/record.js";
+import { SimEventPatternNode } from "./sim-event-pattern-node.js";
+import { eventPatternRefusal } from "./sim-event-pattern-refusals.js";
+/**
+ * The longest event pattern real EventBridge takes.
+ */
+const maximumPatternLength = 4096;
+/**
+ * One rule's event pattern.
+ *
+ * A pattern has the same shape as the events it matches: a key in the pattern
+ * names a field of the event, and a nested object in the pattern is a pattern
+ * for the nested object in the event. Every key has to match, so a pattern
+ * with more keys matches fewer events.
+ *
+ * The string it was written as is kept, because DescribeRule reports the
+ * pattern back and a caller comparing it against what they sent should see
+ * what they sent rather than a re-serialised version of it.
+ */
+export class SimEventPattern {
+    source;
+    root;
+    constructor(source, root) {
+        this.source = source;
+        this.root = root;
+    }
+    /**
+     * Read a pattern from the JSON a request carries.
+     */
+    static of(source) {
+        if (source.length > maximumPatternLength) {
+            throw eventPatternRefusal(`an event pattern is at most ${String(maximumPatternLength)} ` +
+                `characters, and this one is ${String(source.length)}`);
+        }
+        return new this(source, SimEventPatternNode.of(this.parse(source)));
+    }
+    /**
+     * Read the pattern JSON, refusing anything that is not a JSON object.
+     */
+    static parse(source) {
+        let parsed;
+        try {
+            parsed = JSON.parse(source);
+        }
+        catch {
+            throw eventPatternRefusal("the event pattern is not valid JSON");
+        }
+        if (!isRecord(parsed)) {
+            throw eventPatternRefusal("an event pattern is a JSON object, shaped like the events it matches");
+        }
+        return parsed;
+    }
+    /**
+     * Whether an event matches this pattern.
+     *
+     * An event a bus received arrives as its envelope, and one a caller handed
+     * to TestEventPattern arrives as the object their JSON parsed to. Both are
+     * read the same way: by key, from the top down.
+     */
+    matches(event) {
+        return this.root.matches(event);
+    }
+}
+//# sourceMappingURL=sim-event-pattern.js.map

package/dist/service/eventbridge/pattern/sim-event-pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-event-pattern.js","sourceRoot":"","sources":["../../../../src/service/eventbridge/pattern/sim-event-pattern.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAG9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAEtE;;GAEG;AACH,MAAM,oBAAoB,GAAG,IAAI,CAAC;AAElC;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,eAAe;IACV,MAAM,CAAS;IAEd,IAAI,CAAsB;IAE3C,YAAoB,MAAc,EAAE,IAAyB;QAC3D,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,MAAc;QACtB,IAAI,MAAM,CAAC,MAAM,GAAG,oBAAoB,EAAE,CAAC;YACzC,MAAM,mBAAmB,CACvB,+BAA+B,MAAM,CAAC,oBAAoB,CAAC,GAAG;gBAC5D,+BAA+B,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CACzD,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,IAAI,CAAC,MAAM,EAAE,mBAAmB,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACtE,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,KAAK,CAAC,MAAc;QACjC,IAAI,MAAe,CAAC;QAEpB,IAAI,CAAC;YACH,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC9B,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,mBAAmB,CAAC,qCAAqC,CAAC,CAAC;QACnE,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACtB,MAAM,mBAAmB,CACvB,sEAAsE,CACvE,CAAC;QACJ,CAAC;QAED,OAAO,MAAmC,CAAC;IAC7C,CAAC;IAED;;;;;;OAMG;IACH,OAAO,CAAC,KAAuD;QAC7D,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;CACF"}

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

@@ -0,0 +1,65 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimEventBusStore } from "../bus/sim-event-bus-store.js";
+import type { SimEventBridgeDeliveryTargets } from "../delivery/sim-event-bridge-delivery.js";
+import type { SimEventBridgeDeliveryFailure } from "../delivery/sim-event-bridge-delivery-failures.js";
+import type { SimEventBridgeEvent } from "../event/sim-event-bridge-event.js";
+import type { SimEventRule } from "../rule/sim-event-rule.js";
+import type { SimEventRuleStore } from "../rule/sim-event-rule-store.js";
+import type { SimEventTargetStore } from "../target/sim-event-target-store.js";
+interface SimEventBridgeRouterProperties {
+    readonly buses: SimEventBusStore;
+    readonly rules: SimEventRuleStore;
+    readonly targets: SimEventTargetStore;
+    readonly endpoints: SimEventBridgeDeliveryTargets;
+    readonly background: BackgroundScheduler;
+    readonly accountId: string;
+}
+/**
+ * Works out which of a bus's rules an event matches, and sends it on.
+ *
+ * Every enabled rule on the bus is asked. Rules are independent, so one rule's
+ * pattern has nothing to do with whether another matches, and an event
+ * matching two rules goes to the targets of both.
+ *
+ * Delivery happens on the background scheduler, as real EventBridge delivers
+ * after PutEvents has been answered: an event gets an id whether or not
+ * anything downstream takes it. `simAws.backgroundTasksComplete()` is what
+ * waits for it.
+ */
+export declare class SimEventBridgeRouter {
+    private readonly buses;
+    private readonly rules;
+    private readonly targets;
+    private readonly background;
+    private readonly accountId;
+    private readonly delivery;
+    constructor(properties: SimEventBridgeRouterProperties);
+    /**
+     * Every delivery this scope could not make.
+     */
+    get deliveryFailures(): readonly SimEventBridgeDeliveryFailure[];
+    /**
+     * Put an event onto the bus it was addressed to, and send it to the targets
+     * of every rule it matched.
+     *
+     * A bus that is not there takes the event nowhere, and the caller is not
+     * told: real EventBridge answers a PutEvents naming an unknown bus with a
+     * success and drops the event.
+     */
+    deliver(busName: string, event: SimEventBridgeEvent): void;
+    /**
+     * Send a scheduled rule's own event to its targets.
+     *
+     * This does not go through pattern matching, because nothing put it onto the
+     * bus: the rule's schedule produced it and the rule is the only thing it is
+     * for. It is still recorded on the bus, so a test with no target yet can see
+     * what firing produced through `eventsOn(...)`.
+     */
+    fire(rule: SimEventRule, event: SimEventBridgeEvent): void;
+    /**
+     * Schedule one event for every target of a rule that matched it.
+     */
+    private send;
+}
+export {};
+//# sourceMappingURL=sim-event-bridge-router.d.ts.map

package/dist/service/eventbridge/routing/sim-event-bridge-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-event-bridge-router.d.ts","sourceRoot":"","sources":["../../../../src/service/eventbridge/routing/sim-event-bridge-router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAClF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,0CAA0C,CAAC;AAC9F,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mDAAmD,CAAC;AAEvG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAC9E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAE/E,UAAU,8BAA8B;IACtC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC;IACtC,QAAQ,CAAC,SAAS,EAAE,6BAA6B,CAAC;IAClD,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAC1C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA+B;IAExD,YAAY,UAAU,EAAE,8BAA8B,EASrD;IAED;;OAEG;IACH,IAAI,gBAAgB,IAAI,SAAS,6BAA6B,EAAE,CAE/D;IAED;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAoBzD;IAED;;;;;;;OAOG;IACH,IAAI,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAIzD;IAED;;OAEG;IACH,OAAO,CAAC,IAAI;CAeb"}

package/dist/service/eventbridge/routing/sim-event-bridge-router.js

@@ -0,0 +1,89 @@
+import { SimEventBridgeTargetDelivery } from "../delivery/sim-event-bridge-target-delivery.js";
+/**
+ * Works out which of a bus's rules an event matches, and sends it on.
+ *
+ * Every enabled rule on the bus is asked. Rules are independent, so one rule's
+ * pattern has nothing to do with whether another matches, and an event
+ * matching two rules goes to the targets of both.
+ *
+ * Delivery happens on the background scheduler, as real EventBridge delivers
+ * after PutEvents has been answered: an event gets an id whether or not
+ * anything downstream takes it. `simAws.backgroundTasksComplete()` is what
+ * waits for it.
+ */
+export class SimEventBridgeRouter {
+    buses;
+    rules;
+    targets;
+    background;
+    accountId;
+    delivery;
+    constructor(properties) {
+        this.buses = properties.buses;
+        this.rules = properties.rules;
+        this.targets = properties.targets;
+        this.background = properties.background;
+        this.accountId = properties.accountId;
+        this.delivery = new SimEventBridgeTargetDelivery({
+            endpoints: properties.endpoints,
+        });
+    }
+    /**
+     * Every delivery this scope could not make.
+     */
+    get deliveryFailures() {
+        return this.delivery.deliveryFailures;
+    }
+    /**
+     * Put an event onto the bus it was addressed to, and send it to the targets
+     * of every rule it matched.
+     *
+     * A bus that is not there takes the event nowhere, and the caller is not
+     * told: real EventBridge answers a PutEvents naming an unknown bus with a
+     * success and drops the event.
+     */
+    deliver(busName, event) {
+        const bus = this.buses.find(busName);
+        if (bus === undefined) {
+            return;
+        }
+        const envelope = event.toEnvelope();
+        const matched = this.rules
+            .forBus(busName)
+            .filter((rule) => rule.matches(envelope));
+        bus.receive(event, matched.map((rule) => rule.name.value));
+        for (const rule of matched) {
+            this.send(rule, event);
+        }
+    }
+    /**
+     * Send a scheduled rule's own event to its targets.
+     *
+     * This does not go through pattern matching, because nothing put it onto the
+     * bus: the rule's schedule produced it and the rule is the only thing it is
+     * for. It is still recorded on the bus, so a test with no target yet can see
+     * what firing produced through `eventsOn(...)`.
+     */
+    fire(rule, event) {
+        this.buses.find(rule.busName.value)?.receive(event, [rule.name.value]);
+        this.send(rule, event);
+    }
+    /**
+     * Schedule one event for every target of a rule that matched it.
+     */
+    send(rule, event) {
+        const targets = this.targets.forRule(rule.busName.value, rule.name.value);
+        for (const target of targets) {
+            this.background.schedule(async () => {
+                await this.delivery.deliver({
+                    target,
+                    event,
+                    ruleArn: rule.arn,
+                    ruleName: rule.name.value,
+                    ruleOwnerAccountId: this.accountId,
+                });
+            });
+        }
+    }
+}
+//# sourceMappingURL=sim-event-bridge-router.js.map

package/dist/service/eventbridge/routing/sim-event-bridge-router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-event-bridge-router.js","sourceRoot":"","sources":["../../../../src/service/eventbridge/routing/sim-event-bridge-router.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,4BAA4B,EAAE,MAAM,iDAAiD,CAAC;AAe/F;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,oBAAoB;IACd,KAAK,CAAmB;IACxB,KAAK,CAAoB;IACzB,OAAO,CAAsB;IAC7B,UAAU,CAAsB;IAChC,SAAS,CAAS;IAClB,QAAQ,CAA+B;IAExD,YAAY,UAA0C;QACpD,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;QAClC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;QACxC,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;QACtC,IAAI,CAAC,QAAQ,GAAG,IAAI,4BAA4B,CAAC;YAC/C,SAAS,EAAE,UAAU,CAAC,SAAS;SAChC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC;IACxC,CAAC;IAED;;;;;;;OAOG;IACH,OAAO,CAAC,OAAe,EAAE,KAA0B;QACjD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAErC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACtB,OAAO;QACT,CAAC;QAED,MAAM,QAAQ,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC;QACpC,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK;aACvB,MAAM,CAAC,OAAO,CAAC;aACf,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;QAE5C,GAAG,CAAC,OAAO,CACT,KAAK,EACL,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CACvC,CAAC;QAEF,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,CAAC;YAC3B,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACzB,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACH,IAAI,CAAC,IAAkB,EAAE,KAA0B;QACjD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAEvE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACzB,CAAC;IAED;;OAEG;IACK,IAAI,CAAC,IAAkB,EAAE,KAA0B;QACzD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAE1E,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,IAAI,EAAE;gBAClC,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;oBAC1B,MAAM;oBACN,KAAK;oBACL,OAAO,EAAE,IAAI,CAAC,GAAG;oBACjB,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK;oBACzB,kBAAkB,EAAE,IAAI,CAAC,SAAS;iBACnC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;CACF"}

package/dist/service/eventbridge/rule/sim-event-rule-arn.d.ts

@@ -0,0 +1,17 @@
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimEventBusName } from "../bus/sim-event-bus-name.js";
+/**
+ * The ARN of one rule, which names the bus it is on unless that is the default
+ * one.
+ *
+ * A rule on the default bus is `rule/<name>`, and a rule on a custom bus is
+ * `rule/<bus>/<name>`. That is what keeps two rules of the same name on two
+ * buses apart, and it is why a rule ARN can carry one more `/` than an event
+ * bus ARN does.
+ *
+ * Both the rule itself and the authorization of a request that names one build
+ * their ARN here, since a request has to authorize against the ARN a rule
+ * would have before knowing whether that rule exists.
+ */
+export declare function eventRuleArn(ruleName: string, busName: SimEventBusName, scope: SimAwsAccountRegionScope): string;
+//# sourceMappingURL=sim-event-rule-arn.d.ts.map

package/dist/service/eventbridge/rule/sim-event-rule-arn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-event-rule-arn.d.ts","sourceRoot":"","sources":["../../../../src/service/eventbridge/rule/sim-event-rule-arn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AAC1F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,wBAAwB,GAC9B,MAAM,CAQR"}

package/dist/service/eventbridge/rule/sim-event-rule-arn.js

@@ -0,0 +1,21 @@
+/**
+ * The ARN of one rule, which names the bus it is on unless that is the default
+ * one.
+ *
+ * A rule on the default bus is `rule/<name>`, and a rule on a custom bus is
+ * `rule/<bus>/<name>`. That is what keeps two rules of the same name on two
+ * buses apart, and it is why a rule ARN can carry one more `/` than an event
+ * bus ARN does.
+ *
+ * Both the rule itself and the authorization of a request that names one build
+ * their ARN here, since a request has to authorize against the ARN a rule
+ * would have before knowing whether that rule exists.
+ */
+export function eventRuleArn(ruleName, busName, scope) {
+    const prefix = `arn:aws:events:${scope.regionName}:${scope.accountId}:rule/`;
+    if (busName.isDefault) {
+        return prefix + ruleName;
+    }
+    return `${prefix}${busName.value}/${ruleName}`;
+}
+//# sourceMappingURL=sim-event-rule-arn.js.map

package/dist/service/eventbridge/rule/sim-event-rule-arn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-event-rule-arn.js","sourceRoot":"","sources":["../../../../src/service/eventbridge/rule/sim-event-rule-arn.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,YAAY,CAC1B,QAAgB,EAChB,OAAwB,EACxB,KAA+B;IAE/B,MAAM,MAAM,GAAG,kBAAkB,KAAK,CAAC,UAAU,IAAI,KAAK,CAAC,SAAS,QAAQ,CAAC;IAE7E,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;QACtB,OAAO,MAAM,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC,KAAK,IAAI,QAAQ,EAAE,CAAC;AACjD,CAAC"}

package/dist/service/eventbridge/rule/sim-event-rule-name.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The name of one simulated rule.
+ *
+ * A rule name is unique within one event bus rather than within the Account,
+ * so two buses may each have a rule called `orders`.
+ */
+export declare class SimEventRuleName {
+    readonly value: string;
+    private constructor();
+    /**
+     * Read the rule name a request has to carry.
+     */
+    static required(name: string | undefined): SimEventRuleName;
+    /**
+     * Read a rule name from request input, refusing one real EventBridge would
+     * refuse.
+     */
+    static of(value: string): SimEventRuleName;
+}
+//# sourceMappingURL=sim-event-rule-name.d.ts.map

package/dist/service/eventbridge/rule/sim-event-rule-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-event-rule-name.d.ts","sourceRoot":"","sources":["../../../../src/service/eventbridge/rule/sim-event-rule-name.ts"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,qBAAa,gBAAgB;IAC3B,SAAgB,KAAK,EAAE,MAAM,CAAC;IAE9B,OAAO,eAEN;IAED;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,CAQ1D;IAED;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,CAWzC;CACF"}

package/dist/service/eventbridge/rule/sim-event-rule-name.js

@@ -0,0 +1,43 @@
+import { SimEventBridgeValidationException } from "../error/sim-event-bridge.error.js";
+/**
+ * Real EventBridge allows alphanumerics, full stops, hyphens and underscores,
+ * up to 64 characters. A rule name is shorter than a bus name and takes no
+ * `/`, even for a rule on a custom bus, where the bus name goes in the ARN
+ * rather than in the rule's own name.
+ */
+const ruleNamePattern = /^[.\-_A-Za-z0-9]{1,64}$/;
+/**
+ * The name of one simulated rule.
+ *
+ * A rule name is unique within one event bus rather than within the Account,
+ * so two buses may each have a rule called `orders`.
+ */
+export class SimEventRuleName {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    /**
+     * Read the rule name a request has to carry.
+     */
+    static required(name) {
+        if (name === undefined || name === "") {
+            throw new SimEventBridgeValidationException("Invalid parameter: Name is required");
+        }
+        return this.of(name);
+    }
+    /**
+     * Read a rule name from request input, refusing one real EventBridge would
+     * refuse.
+     */
+    static of(value) {
+        if (!ruleNamePattern.test(value)) {
+            throw new SimEventBridgeValidationException(`Invalid parameter: Name Reason: '${value}' is not a valid rule ` +
+                `name. Rule names are made up of only letters, numbers, full ` +
+                `stops, hyphens and underscores, and are between 1 and 64 ` +
+                `characters long.`);
+        }
+        return new this(value);
+    }
+}
+//# sourceMappingURL=sim-event-rule-name.js.map