@kensio/yulin 1.19.2 → 1.19.3

package/dist/service/cognito/user-pool/message/sim-cognito-email-configuration-reader.js

@@ -0,0 +1,72 @@
+import { SimCognitoInvalidParameterException } from "../../error/sim-cognito.error.js";
+import { simCognitoEmailSourceIdentity, } from "./sim-cognito-email-source-arn.js";
+import { simCognitoEmailSendingAccounts, } from "./sim-cognito-email-configuration.js";
+/**
+ * Reads the keys of one `EmailConfiguration`, refusing a value Cognito would
+ * refuse.
+ *
+ * The configuration arrives as a bare object because CloudFormation hands one
+ * over with whatever a template wrote in it, so every key is checked here
+ * rather than trusted from the type.
+ */
+export class SimCognitoEmailConfigurationReader {
+    /** The configuration as given, which is also what a describe reports. */
+    declared;
+    #operation;
+    /**
+     * The keys as given, held in a Map rather than read off the object. What
+     * arrives is whatever a template wrote, so a key such as `__proto__` reaches
+     * here and a Map is where it means nothing.
+     */
+    #values;
+    constructor(declared, operation) {
+        this.declared = declared;
+        this.#operation = operation;
+        this.#values = new Map(Object.entries(declared ?? {}));
+    }
+    /**
+     * One key that has to be a string where it is there at all.
+     */
+    string(key) {
+        const value = this.#values.get(key);
+        if (value === undefined) {
+            return undefined;
+        }
+        if (typeof value !== "string") {
+            throw new SimCognitoInvalidParameterException(`${this.#operation} EmailConfiguration ${key} must be a string`);
+        }
+        return value;
+    }
+    /**
+     * Which service the configuration asked to send through, refusing a value
+     * Cognito has no meaning for.
+     */
+    sendingAccount() {
+        const declared = this.string("EmailSendingAccount");
+        if (declared === undefined) {
+            return "COGNITO_DEFAULT";
+        }
+        if (!simCognitoEmailSendingAccounts.includes(declared)) {
+            throw new SimCognitoInvalidParameterException(`${this.#operation} EmailConfiguration EmailSendingAccount ` +
+                `'${declared}' is not one of ${simCognitoEmailSendingAccounts.join(", ")}`);
+        }
+        return declared;
+    }
+    /**
+     * The identity a `SourceArn` names, refusing a value that names something
+     * other than an SES email identity.
+     */
+    sourceIdentity() {
+        const sourceArn = this.string("SourceArn");
+        if (sourceArn === undefined) {
+            return undefined;
+        }
+        const identity = simCognitoEmailSourceIdentity(sourceArn);
+        if (identity === undefined) {
+            throw new SimCognitoInvalidParameterException(`${this.#operation} EmailConfiguration SourceArn '${sourceArn}' is ` +
+                `not the ARN of an SES email identity`);
+        }
+        return identity;
+    }
+}
+//# sourceMappingURL=sim-cognito-email-configuration-reader.js.map

package/dist/service/cognito/user-pool/message/sim-cognito-email-configuration-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-cognito-email-configuration-reader.js","sourceRoot":"","sources":["../../../../../src/service/cognito/user-pool/message/sim-cognito-email-configuration-reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mCAAmC,EAAE,MAAM,kCAAkC,CAAC;AACvF,OAAO,EACL,6BAA6B,GAE9B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,8BAA8B,GAG/B,MAAM,sCAAsC,CAAC;AAE9C;;;;;;;GAOG;AACH,MAAM,OAAO,kCAAkC;IAC7C,yEAAyE;IACzD,QAAQ,CAA+C;IAE9D,UAAU,CAAS;IAE5B;;;;OAIG;IACM,OAAO,CAA+B;IAE/C,YAAY,QAA4B,EAAE,SAAiB;QACzD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC5B,IAAI,CAAC,OAAO,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,CAAC;IACzD,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,GAAW;QAChB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAEpC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,MAAM,IAAI,mCAAmC,CAC3C,GAAG,IAAI,CAAC,UAAU,uBAAuB,GAAG,mBAAmB,CAChE,CAAC;QACJ,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;OAGG;IACH,cAAc;QACZ,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC;QAEpD,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO,iBAAiB,CAAC;QAC3B,CAAC;QAED,IAAI,CAAC,8BAA8B,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YACvD,MAAM,IAAI,mCAAmC,CAC3C,GAAG,IAAI,CAAC,UAAU,0CAA0C;gBAC1D,IAAI,QAAQ,mBAAmB,8BAA8B,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC7E,CAAC;QACJ,CAAC;QAED,OAAO,QAAyC,CAAC;IACnD,CAAC;IAED;;;OAGG;IACH,cAAc;QACZ,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAE3C,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,QAAQ,GAAG,6BAA6B,CAAC,SAAS,CAAC,CAAC;QAE1D,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,MAAM,IAAI,mCAAmC,CAC3C,GAAG,IAAI,CAAC,UAAU,kCAAkC,SAAS,OAAO;gBAClE,sCAAsC,CACzC,CAAC;QACJ,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF"}

package/dist/service/cognito/user-pool/message/sim-cognito-email-configuration.d.ts

@@ -0,0 +1,85 @@
+import type { SimCognitoEmailSourceIdentity } from "./sim-cognito-email-source-arn.js";
+/**
+ * Which service delivers a pool's email.
+ *
+ * `COGNITO_DEFAULT` is Cognito's own sending, capped at a low daily limit on
+ * real AWS. `DEVELOPER` is the account's own SES.
+ */
+export type SimCognitoEmailSendingAccount = "COGNITO_DEFAULT" | "DEVELOPER";
+/**
+ * The two values `EmailSendingAccount` has, which is also what a refusal of a
+ * third names.
+ */
+export declare const simCognitoEmailSendingAccounts: readonly string[];
+/**
+ * The address real Cognito sends from when it is sending the email itself and
+ * was given no other one.
+ */
+export declare const simCognitoDefaultFromAddress = "no-reply@verificationemail.com";
+/**
+ * A pool's `EmailConfiguration`, as a described pool reports it.
+ *
+ * https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_EmailConfigurationType.html
+ */
+export interface SimCognitoEmailConfigurationType {
+    readonly ConfigurationSet?: string | undefined;
+    readonly EmailSendingAccount?: string | undefined;
+    readonly From?: string | undefined;
+    readonly ReplyToEmailAddress?: string | undefined;
+    readonly SourceArn?: string | undefined;
+}
+/**
+ * How a simulated user pool sends the messages it writes.
+ *
+ * A pool with no `EmailConfiguration`, and one that named `COGNITO_DEFAULT`,
+ * send through Cognito itself. The pool records what it would have sent and
+ * nothing else observes it, because on real AWS nothing else does either:
+ * Cognito's built-in sending goes through no other service, so there is no
+ * second place a test could read it from.
+ *
+ * A pool that named `DEVELOPER` sends through the account's SES in the region
+ * its `SourceArn` names, and the message is recorded there as well as on the
+ * pool. That is the difference the whole setting exists for, and the reason it
+ * is simulated rather than refused: an account configured for SES and still in
+ * the SES sandbox delivers nothing, and a pool recording only its own messages
+ * would report that as a working sign-up.
+ *
+ * `SourceArn` is read for its region and identity name only. See
+ * `SimCognitoEmailSourceIdentity` for why the account id in it is read past.
+ */
+export declare class SimCognitoEmailConfiguration {
+    #private;
+    readonly sendingAccount: SimCognitoEmailSendingAccount;
+    /**
+     * The address the messages come from, with the display name where the
+     * configuration gave one.
+     *
+     * A pool that named no `From` sends from the address its `SourceArn` names,
+     * as real Cognito does, and one with neither sends from Cognito's own
+     * address. A `SourceArn` naming a domain has no address to fall back on, so
+     * such a pool has to say what its `From` is.
+     */
+    readonly from: string;
+    readonly replyToEmailAddress: string | undefined;
+    readonly configurationSet: string | undefined;
+    /**
+     * The SES identity the pool sends through, and nothing where the pool sends
+     * through Cognito itself.
+     *
+     * A `COGNITO_DEFAULT` pool with a `SourceArn` has one on real AWS too, and
+     * uses it only as the address the built-in sending writes as. It is left out
+     * here because nothing reads it: the `From` above already carries it.
+     */
+    readonly sourceIdentity: SimCognitoEmailSourceIdentity | undefined;
+    constructor(declared: object | undefined, operation: string);
+    /**
+     * The configuration as `DescribeUserPool` reports it, and nothing for a pool
+     * that declared none.
+     *
+     * Real Cognito reports back what the request set rather than the defaults
+     * behind it, so a pool created without an `EmailConfiguration` describes
+     * itself without one even though it sends from Cognito's own address.
+     */
+    toOutput(): SimCognitoEmailConfigurationType | undefined;
+}
+//# sourceMappingURL=sim-cognito-email-configuration.d.ts.map

package/dist/service/cognito/user-pool/message/sim-cognito-email-configuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-cognito-email-configuration.d.ts","sourceRoot":"","sources":["../../../../../src/service/cognito/user-pool/message/sim-cognito-email-configuration.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mCAAmC,CAAC;AAEvF;;;;;GAKG;AACH,MAAM,MAAM,6BAA6B,GAAG,iBAAiB,GAAG,WAAW,CAAC;AAE5E;;;GAGG;AACH,eAAO,MAAM,8BAA8B,EAAE,SAAS,MAAM,EAG3D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,mCAAmC,CAAC;AAE7E;;;;GAIG;AACH,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/C,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,4BAA4B;;IACvC,SAAgB,cAAc,EAAE,6BAA6B,CAAC;IAE9D;;;;;;;;OAQG;IACH,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B,SAAgB,mBAAmB,EAAE,MAAM,GAAG,SAAS,CAAC;IAExD,SAAgB,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IAErD;;;;;;;OAOG;IACH,SAAgB,cAAc,EAAE,6BAA6B,GAAG,SAAS,CAAC;IAI1E,YAAY,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,EAiB1D;IAED;;;;;;;OAOG;IACH,QAAQ,IAAI,gCAAgC,GAAG,SAAS,CAEvD;CACF"}

package/dist/service/cognito/user-pool/message/sim-cognito-email-configuration.js

@@ -0,0 +1,117 @@
+import { SimCognitoInvalidParameterException } from "../../error/sim-cognito.error.js";
+import { SimCognitoEmailConfigurationReader } from "./sim-cognito-email-configuration-reader.js";
+/**
+ * The two values `EmailSendingAccount` has, which is also what a refusal of a
+ * third names.
+ */
+export const simCognitoEmailSendingAccounts = [
+    "COGNITO_DEFAULT",
+    "DEVELOPER",
+];
+/**
+ * The address real Cognito sends from when it is sending the email itself and
+ * was given no other one.
+ */
+export const simCognitoDefaultFromAddress = "no-reply@verificationemail.com";
+/**
+ * How a simulated user pool sends the messages it writes.
+ *
+ * A pool with no `EmailConfiguration`, and one that named `COGNITO_DEFAULT`,
+ * send through Cognito itself. The pool records what it would have sent and
+ * nothing else observes it, because on real AWS nothing else does either:
+ * Cognito's built-in sending goes through no other service, so there is no
+ * second place a test could read it from.
+ *
+ * A pool that named `DEVELOPER` sends through the account's SES in the region
+ * its `SourceArn` names, and the message is recorded there as well as on the
+ * pool. That is the difference the whole setting exists for, and the reason it
+ * is simulated rather than refused: an account configured for SES and still in
+ * the SES sandbox delivers nothing, and a pool recording only its own messages
+ * would report that as a working sign-up.
+ *
+ * `SourceArn` is read for its region and identity name only. See
+ * `SimCognitoEmailSourceIdentity` for why the account id in it is read past.
+ */
+export class SimCognitoEmailConfiguration {
+    sendingAccount;
+    /**
+     * The address the messages come from, with the display name where the
+     * configuration gave one.
+     *
+     * A pool that named no `From` sends from the address its `SourceArn` names,
+     * as real Cognito does, and one with neither sends from Cognito's own
+     * address. A `SourceArn` naming a domain has no address to fall back on, so
+     * such a pool has to say what its `From` is.
+     */
+    from;
+    replyToEmailAddress;
+    configurationSet;
+    /**
+     * The SES identity the pool sends through, and nothing where the pool sends
+     * through Cognito itself.
+     *
+     * A `COGNITO_DEFAULT` pool with a `SourceArn` has one on real AWS too, and
+     * uses it only as the address the built-in sending writes as. It is left out
+     * here because nothing reads it: the `From` above already carries it.
+     */
+    sourceIdentity;
+    #declared;
+    constructor(declared, operation) {
+        const read = new SimCognitoEmailConfigurationReader(declared, operation);
+        const sourceIdentity = read.sourceIdentity();
+        const declaredFrom = read.string("From");
+        this.#declared = read.declared;
+        this.sendingAccount = read.sendingAccount();
+        this.configurationSet = read.string("ConfigurationSet");
+        this.replyToEmailAddress = read.string("ReplyToEmailAddress");
+        this.from =
+            declaredFrom ?? addressOf(sourceIdentity) ?? simCognitoDefaultFromAddress;
+        this.sourceIdentity =
+            this.sendingAccount === "DEVELOPER" ? sourceIdentity : undefined;
+        if (this.sendingAccount === "DEVELOPER") {
+            refuseWithoutSender(operation, sourceIdentity, declaredFrom);
+        }
+    }
+    /**
+     * The configuration as `DescribeUserPool` reports it, and nothing for a pool
+     * that declared none.
+     *
+     * Real Cognito reports back what the request set rather than the defaults
+     * behind it, so a pool created without an `EmailConfiguration` describes
+     * itself without one even though it sends from Cognito's own address.
+     */
+    toOutput() {
+        return this.#declared;
+    }
+}
+/**
+ * The address an identity gives a pool to send as, and nothing for a domain.
+ *
+ * A domain identity covers every address at it and names none of them, so
+ * there is nothing here for a `From` to default to.
+ */
+function addressOf(identity) {
+    return identity === undefined || identity.isDomain
+        ? undefined
+        : identity.identityName;
+}
+/**
+ * Refuse a pool that sends through SES without saying what it sends as.
+ *
+ * Real Cognito needs the `SourceArn`, because the identity is what the account
+ * has proved it owns. It needs the `From` as well where that identity is a
+ * domain, since a domain gives it no one address to write as.
+ */
+function refuseWithoutSender(operation, sourceIdentity, declaredFrom) {
+    if (sourceIdentity === undefined) {
+        throw new SimCognitoInvalidParameterException(`${operation} EmailConfiguration with EmailSendingAccount 'DEVELOPER' ` +
+            `needs a SourceArn naming the SES email identity the pool sends ` +
+            `through`);
+    }
+    if (declaredFrom === undefined && sourceIdentity.isDomain) {
+        throw new SimCognitoInvalidParameterException(`${operation} EmailConfiguration with a SourceArn naming the domain ` +
+            `'${sourceIdentity.identityName}' needs a From address, because a ` +
+            `domain identity gives Cognito no one address to send as`);
+    }
+}
+//# sourceMappingURL=sim-cognito-email-configuration.js.map

package/dist/service/cognito/user-pool/message/sim-cognito-email-configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-cognito-email-configuration.js","sourceRoot":"","sources":["../../../../../src/service/cognito/user-pool/message/sim-cognito-email-configuration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mCAAmC,EAAE,MAAM,kCAAkC,CAAC;AACvF,OAAO,EAAE,kCAAkC,EAAE,MAAM,6CAA6C,CAAC;AAWjG;;;GAGG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAsB;IAC/D,iBAAiB;IACjB,WAAW;CACZ,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,gCAAgC,CAAC;AAe7E;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,OAAO,4BAA4B;IACvB,cAAc,CAAgC;IAE9D;;;;;;;;OAQG;IACa,IAAI,CAAS;IAEb,mBAAmB,CAAqB;IAExC,gBAAgB,CAAqB;IAErD;;;;;;;OAOG;IACa,cAAc,CAA4C;IAEjE,SAAS,CAA+C;IAEjE,YAAY,QAA4B,EAAE,SAAiB;QACzD,MAAM,IAAI,GAAG,IAAI,kCAAkC,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;QACzE,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QAC7C,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAEzC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC/B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QAC5C,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC;QACxD,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC;QAC9D,IAAI,CAAC,IAAI;YACP,YAAY,IAAI,SAAS,CAAC,cAAc,CAAC,IAAI,4BAA4B,CAAC;QAC5E,IAAI,CAAC,cAAc;YACjB,IAAI,CAAC,cAAc,KAAK,WAAW,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC;QAEnE,IAAI,IAAI,CAAC,cAAc,KAAK,WAAW,EAAE,CAAC;YACxC,mBAAmB,CAAC,SAAS,EAAE,cAAc,EAAE,YAAY,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACH,QAAQ;QACN,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;CACF;AAED;;;;;GAKG;AACH,SAAS,SAAS,CAChB,QAAmD;IAEnD,OAAO,QAAQ,KAAK,SAAS,IAAI,QAAQ,CAAC,QAAQ;QAChD,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,QAAQ,CAAC,YAAY,CAAC;AAC5B,CAAC;AAED;;;;;;GAMG;AACH,SAAS,mBAAmB,CAC1B,SAAiB,EACjB,cAAyD,EACzD,YAAgC;IAEhC,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;QACjC,MAAM,IAAI,mCAAmC,CAC3C,GAAG,SAAS,2DAA2D;YACrE,iEAAiE;YACjE,SAAS,CACZ,CAAC;IACJ,CAAC;IAED,IAAI,YAAY,KAAK,SAAS,IAAI,cAAc,CAAC,QAAQ,EAAE,CAAC;QAC1D,MAAM,IAAI,mCAAmC,CAC3C,GAAG,SAAS,yDAAyD;YACnE,IAAI,cAAc,CAAC,YAAY,oCAAoC;YACnE,yDAAyD,CAC5D,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/service/cognito/user-pool/message/sim-cognito-email-senders.d.ts

@@ -0,0 +1,73 @@
+import type { SimAwsAccountId } from "../../../aws/sim-aws-account-id.js";
+import type { SimCognitoEmailSourceIdentity } from "./sim-cognito-email-source-arn.js";
+/**
+ * A pool asking to send one message through the account's SES.
+ *
+ * The account travels with the request because a pool resolves its identity in
+ * its own account: the `SourceArn` says which region and which identity, and
+ * the pool says which account. See `SimCognitoEmailSourceIdentity` for why the
+ * account in the ARN is read past.
+ */
+export interface SimCognitoEmailSendRequest {
+    readonly identity: SimCognitoEmailSourceIdentity;
+    readonly accountId: SimAwsAccountId;
+    readonly from: string;
+    readonly replyToAddresses: readonly string[];
+    readonly configurationSet: string | undefined;
+    readonly recipient: string;
+    readonly subject: string;
+    readonly body: string;
+}
+/**
+ * Which of a pool's two email failures happened.
+ *
+ * Real Cognito reports them as two different exceptions, and they mean
+ * different things to whoever has to fix the deployment. `identity` is the
+ * pool being unable to use the SES identity at all. `delivery` is SES
+ * refusing the message, which in a simulation means the sandbox.
+ */
+export type SimCognitoEmailSendFailureKind = "identity" | "delivery";
+/**
+ * Why a pool's message never reached SES.
+ */
+export interface SimCognitoEmailSendFailure {
+    readonly kind: SimCognitoEmailSendFailureKind;
+    /**
+     * What went wrong, repeated back in the exception whoever has to fix the
+     * configuration reads.
+     */
+    readonly reason: string;
+}
+/**
+ * The narrow slice of simulated SES a user pool with `EmailSendingAccount:
+ * DEVELOPER` needs.
+ *
+ * A pool asks one thing: send this message, and say why if it could not. The
+ * SES it asks is the one in the region its `SourceArn` names, which need not
+ * be the pool's own region, so the senders come from the whole simulation
+ * rather than from the scope the pool belongs to. Pool triggers reach Lambda
+ * the same way and for the same reason.
+ *
+ * A failure comes back rather than being thrown, because SES's vocabulary for
+ * a refused send is not the pool's: the pool reports it as the Cognito
+ * exception a sign-up would see on real AWS.
+ */
+export interface SimCognitoEmailSenders {
+    send(request: SimCognitoEmailSendRequest): SimCognitoEmailSendFailure | undefined;
+}
+/**
+ * The email senders of a simulated Cognito built without simulated SES, such
+ * as a standalone `SimCognitoIdentityProvider` constructed outside `SimAws`.
+ *
+ * A pool can still be created with an `EmailConfiguration`, because the
+ * identity is only resolved when a message is sent. It is the sign-up that
+ * says there is no SES to reach, rather than the pool creation that would have
+ * to guess.
+ */
+export declare class SimCognitoNoEmailSenders implements SimCognitoEmailSenders {
+    /**
+     * Refuse the send, explaining how to reach an SES.
+     */
+    send(request: SimCognitoEmailSendRequest): SimCognitoEmailSendFailure;
+}
+//# sourceMappingURL=sim-cognito-email-senders.d.ts.map

package/dist/service/cognito/user-pool/message/sim-cognito-email-senders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-cognito-email-senders.d.ts","sourceRoot":"","sources":["../../../../../src/service/cognito/user-pool/message/sim-cognito-email-senders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mCAAmC,CAAC;AAEvF;;;;;;;GAOG;AACH,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,QAAQ,EAAE,6BAA6B,CAAC;IACjD,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,8BAA8B,GAAG,UAAU,GAAG,UAAU,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,IAAI,EAAE,8BAA8B,CAAC;IAE9C;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,sBAAsB;IACrC,IAAI,CACF,OAAO,EAAE,0BAA0B,GAClC,0BAA0B,GAAG,SAAS,CAAC;CAC3C;AAED;;;;;;;;GAQG;AACH,qBAAa,wBAAyB,YAAW,sBAAsB;IACrE;;OAEG;IACH,IAAI,CAAC,OAAO,EAAE,0BAA0B,GAAG,0BAA0B,CAQpE;CACF"}

package/dist/service/cognito/user-pool/message/sim-cognito-email-senders.js

@@ -0,0 +1,23 @@
+/**
+ * The email senders of a simulated Cognito built without simulated SES, such
+ * as a standalone `SimCognitoIdentityProvider` constructed outside `SimAws`.
+ *
+ * A pool can still be created with an `EmailConfiguration`, because the
+ * identity is only resolved when a message is sent. It is the sign-up that
+ * says there is no SES to reach, rather than the pool creation that would have
+ * to guess.
+ */
+export class SimCognitoNoEmailSenders {
+    /**
+     * Refuse the send, explaining how to reach an SES.
+     */
+    send(request) {
+        return {
+            kind: "identity",
+            reason: `${request.identity.identityName} cannot be reached: this ` +
+                `SimCognitoIdentityProvider was built without simulated SES. Reach ` +
+                `Cognito through SimAws to send a user pool's email through SES.`,
+        };
+    }
+}
+//# sourceMappingURL=sim-cognito-email-senders.js.map

package/dist/service/cognito/user-pool/message/sim-cognito-email-senders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-cognito-email-senders.js","sourceRoot":"","sources":["../../../../../src/service/cognito/user-pool/message/sim-cognito-email-senders.ts"],"names":[],"mappings":"AAiEA;;;;;;;;GAQG;AACH,MAAM,OAAO,wBAAwB;IACnC;;OAEG;IACH,IAAI,CAAC,OAAmC;QACtC,OAAO;YACL,IAAI,EAAE,UAAU;YAChB,MAAM,EACJ,GAAG,OAAO,CAAC,QAAQ,CAAC,YAAY,2BAA2B;gBAC3D,oEAAoE;gBACpE,iEAAiE;SACpE,CAAC;IACJ,CAAC;CACF"}

package/dist/service/cognito/user-pool/message/sim-cognito-email-source-arn.d.ts

@@ -0,0 +1,39 @@
+import type { AwsRegionName } from "../../../aws/sim-aws-region.js";
+/**
+ * The SES identity a pool's `SourceArn` names.
+ *
+ * The account the ARN was written with is deliberately absent. A `SourceArn`
+ * synthesized by CDK carries the account the stack deploys to, which is a real
+ * one, while a simulation usually runs under the default simulated account. A
+ * pool resolves its identity in its own account, so the region and the
+ * identity name are what have to meet and the account id in the ARN is read
+ * past. Keying on the whole ARN instead would leave every project rewriting
+ * the account id in its template before a sign-up could send.
+ */
+export interface SimCognitoEmailSourceIdentity {
+    /**
+     * The region the identity is verified in, which is the region of the SES
+     * the pool sends through. Real Cognito restricts which regions a pool may
+     * pair with; nothing here does, so a pool reaches any region's SES.
+     */
+    readonly regionName: AwsRegionName;
+    /** The address or domain, as the ARN spelled it. */
+    readonly identityName: string;
+    /**
+     * Whether the identity is a domain rather than one address.
+     *
+     * SES decides this by whether the name has an `@` in it, and so does this.
+     * A domain has no address for Cognito to send as, which is why a pool
+     * naming one has to say what its `From` is.
+     */
+    readonly isDomain: boolean;
+}
+/**
+ * Read the SES identity out of a pool's `SourceArn`, or nothing where the
+ * value names something else.
+ *
+ * A caller refusing the value is what turns `undefined` into an error, because
+ * the two commands that carry a `SourceArn` word their refusals differently.
+ */
+export declare function simCognitoEmailSourceIdentity(sourceArn: string): SimCognitoEmailSourceIdentity | undefined;
+//# sourceMappingURL=sim-cognito-email-source-arn.d.ts.map

package/dist/service/cognito/user-pool/message/sim-cognito-email-source-arn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-cognito-email-source-arn.d.ts","sourceRoot":"","sources":["../../../../../src/service/cognito/user-pool/message/sim-cognito-email-source-arn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAEpE;;;;;;;;;;GAUG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC;IAEnC,oDAAoD;IACpD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAYD;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,MAAM,GAChB,6BAA6B,GAAG,SAAS,CAiB3C"}

package/dist/service/cognito/user-pool/message/sim-cognito-email-source-arn.js

@@ -0,0 +1,33 @@
+/**
+ * `arn:aws:ses:<region>:<account>:identity/<name>`, which is the only SES ARN
+ * a `SourceArn` is allowed to be.
+ *
+ * The account segment is held to digits the way the AWS pattern holds it, even
+ * though the value is read past. A malformed ARN is worth refusing whether or
+ * not this goes on to use the part that is malformed.
+ */
+const identityArnPattern = /^arn:[^:]*:ses:([^:]+):[0-9]+:identity\/(.+)$/;
+/**
+ * Read the SES identity out of a pool's `SourceArn`, or nothing where the
+ * value names something else.
+ *
+ * A caller refusing the value is what turns `undefined` into an error, because
+ * the two commands that carry a `SourceArn` word their refusals differently.
+ */
+export function simCognitoEmailSourceIdentity(sourceArn) {
+    const parts = identityArnPattern.exec(sourceArn);
+    const regionName = parts?.[1];
+    const identityName = parts?.[2];
+    if (regionName === undefined || identityName === undefined) {
+        return undefined;
+    }
+    // Read as a region name the way every other ARN parser here reads one. A
+    // spelling no region has resolves to a scope with nothing in it, and the
+    // pool then reports the identity as missing, which is what it is.
+    return {
+        regionName: regionName,
+        identityName,
+        isDomain: !identityName.includes("@"),
+    };
+}
+//# sourceMappingURL=sim-cognito-email-source-arn.js.map

package/dist/service/cognito/user-pool/message/sim-cognito-email-source-arn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-cognito-email-source-arn.js","sourceRoot":"","sources":["../../../../../src/service/cognito/user-pool/message/sim-cognito-email-source-arn.ts"],"names":[],"mappings":"AAkCA;;;;;;;GAOG;AACH,MAAM,kBAAkB,GAAG,+CAA+C,CAAC;AAE3E;;;;;;GAMG;AACH,MAAM,UAAU,6BAA6B,CAC3C,SAAiB;IAEjB,MAAM,KAAK,GAAG,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACjD,MAAM,UAAU,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;IAC9B,MAAM,YAAY,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;IAEhC,IAAI,UAAU,KAAK,SAAS,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;QAC3D,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,yEAAyE;IACzE,yEAAyE;IACzE,kEAAkE;IAClE,OAAO;QACL,UAAU,EAAE,UAA2B;QACvC,YAAY;QACZ,QAAQ,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC;KACtC,CAAC;AACJ,CAAC"}

package/dist/service/cognito/user-pool/message/sim-cognito-pool-email-delivery.d.ts

@@ -0,0 +1,41 @@
+import type { SimCognitoUserPool } from "../sim-cognito-user-pool.js";
+import type { SimCognitoEmailSenders } from "./sim-cognito-email-senders.js";
+import type { SimCognitoMessageDelivery } from "./sim-cognito-message-delivery.js";
+import type { SimCognitoMessageWording } from "./sim-cognito-message-wording.js";
+interface SimCognitoPoolEmailDeliveryProperties {
+    readonly senders: SimCognitoEmailSenders;
+}
+/**
+ * What a pool is about to email, once the wording is settled.
+ */
+interface SimCognitoPoolEmail {
+    readonly pool: SimCognitoUserPool;
+    /** Where the message is going, and by which medium. */
+    readonly delivery: SimCognitoMessageDelivery;
+    readonly wording: SimCognitoMessageWording;
+}
+/**
+ * Sends a pool's email through the account's SES, where the pool asked for
+ * that.
+ *
+ * A pool sending through Cognito's own email passes through here untouched.
+ * There is nowhere for such a message to go: real Cognito's built-in sending
+ * reaches no other AWS service, so the record the pool keeps is the whole of
+ * it.
+ */
+export declare class SimCognitoPoolEmailDelivery {
+    #private;
+    constructor(properties: SimCognitoPoolEmailDeliveryProperties);
+    /**
+     * Put the message through SES, or do nothing where it is a text message or
+     * the pool sends its own email.
+     *
+     * This runs before the pool records the message, so a send SES refuses
+     * leaves the pool without one. The two records then agree: a message the
+     * pool kept is a message SES accepted, which is what makes reading either of
+     * them worth anything.
+     */
+    send(email: SimCognitoPoolEmail): void;
+}
+export {};
+//# sourceMappingURL=sim-cognito-pool-email-delivery.d.ts.map

package/dist/service/cognito/user-pool/message/sim-cognito-pool-email-delivery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-cognito-pool-email-delivery.d.ts","sourceRoot":"","sources":["../../../../../src/service/cognito/user-pool/message/sim-cognito-pool-email-delivery.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,EAEV,sBAAsB,EACvB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AACnF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAEjF,UAAU,qCAAqC;IAC7C,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAC;CAC1C;AAED;;GAEG;AACH,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAElC,uDAAuD;IACvD,QAAQ,CAAC,QAAQ,EAAE,yBAAyB,CAAC;IAC7C,QAAQ,CAAC,OAAO,EAAE,wBAAwB,CAAC;CAC5C;AAED;;;;;;;;GAQG;AACH,qBAAa,2BAA2B;;IAGtC,YAAY,UAAU,EAAE,qCAAqC,EAE5D;IAED;;;;;;;;OAQG;IACH,IAAI,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAmCrC;CACF"}

package/dist/service/cognito/user-pool/message/sim-cognito-pool-email-delivery.js

@@ -0,0 +1,66 @@
+import { assertDefined } from "../../../../util/type-guard/defined.js";
+import { SimCognitoCodeDeliveryFailureException, SimCognitoInvalidEmailRoleAccessPolicyException, } from "../../error/sim-cognito.error.js";
+/**
+ * Sends a pool's email through the account's SES, where the pool asked for
+ * that.
+ *
+ * A pool sending through Cognito's own email passes through here untouched.
+ * There is nowhere for such a message to go: real Cognito's built-in sending
+ * reaches no other AWS service, so the record the pool keeps is the whole of
+ * it.
+ */
+export class SimCognitoPoolEmailDelivery {
+    #senders;
+    constructor(properties) {
+        this.#senders = properties.senders;
+    }
+    /**
+     * Put the message through SES, or do nothing where it is a text message or
+     * the pool sends its own email.
+     *
+     * This runs before the pool records the message, so a send SES refuses
+     * leaves the pool without one. The two records then agree: a message the
+     * pool kept is a message SES accepted, which is what makes reading either of
+     * them worth anything.
+     */
+    send(email) {
+        const configuration = email.pool.settings.emailConfiguration;
+        if (email.delivery.medium !== "EMAIL" ||
+            configuration.sourceIdentity === undefined) {
+            return;
+        }
+        // Every wording an email is written from carries a subject, whether the
+        // pool's own or one a CustomMessage handler wrote. Only a text message
+        // goes without, and one never reaches here.
+        assertDefined(email.wording.subject, "A pool's email wording has a subject");
+        const failure = this.#senders.send({
+            identity: configuration.sourceIdentity,
+            accountId: email.pool.arn.accountId,
+            from: configuration.from,
+            replyToAddresses: configuration.replyToEmailAddress === undefined
+                ? []
+                : [configuration.replyToEmailAddress],
+            configurationSet: configuration.configurationSet,
+            recipient: email.delivery.recipient,
+            subject: email.wording.subject,
+            body: email.wording.body,
+        });
+        if (failure !== undefined) {
+            throw failureException(failure, email.pool);
+        }
+    }
+}
+/**
+ * The exception real Cognito raises for this failure.
+ *
+ * A pool that cannot use its identity and a message SES would not take are two
+ * different problems for whoever has to fix the deployment, and real Cognito
+ * keeps them apart, so the sign-up that hit one says which.
+ */
+function failureException(failure, pool) {
+    const message = `${pool.id} could not send through SES: ${failure.reason}`;
+    return failure.kind === "identity"
+        ? new SimCognitoInvalidEmailRoleAccessPolicyException(message)
+        : new SimCognitoCodeDeliveryFailureException(message);
+}
+//# sourceMappingURL=sim-cognito-pool-email-delivery.js.map

package/dist/service/cognito/user-pool/message/sim-cognito-pool-email-delivery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-cognito-pool-email-delivery.js","sourceRoot":"","sources":["../../../../../src/service/cognito/user-pool/message/sim-cognito-pool-email-delivery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AACvE,OAAO,EACL,sCAAsC,EACtC,+CAA+C,GAChD,MAAM,kCAAkC,CAAC;AAwB1C;;;;;;;;GAQG;AACH,MAAM,OAAO,2BAA2B;IAC7B,QAAQ,CAAyB;IAE1C,YAAY,UAAiD;QAC3D,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,OAAO,CAAC;IACrC,CAAC;IAED;;;;;;;;OAQG;IACH,IAAI,CAAC,KAA0B;QAC7B,MAAM,aAAa,GAAG,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC;QAE7D,IACE,KAAK,CAAC,QAAQ,CAAC,MAAM,KAAK,OAAO;YACjC,aAAa,CAAC,cAAc,KAAK,SAAS,EAC1C,CAAC;YACD,OAAO;QACT,CAAC;QAED,wEAAwE;QACxE,uEAAuE;QACvE,4CAA4C;QAC5C,aAAa,CACX,KAAK,CAAC,OAAO,CAAC,OAAO,EACrB,sCAAsC,CACvC,CAAC;QAEF,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjC,QAAQ,EAAE,aAAa,CAAC,cAAc;YACtC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS;YACnC,IAAI,EAAE,aAAa,CAAC,IAAI;YACxB,gBAAgB,EACd,aAAa,CAAC,mBAAmB,KAAK,SAAS;gBAC7C,CAAC,CAAC,EAAE;gBACJ,CAAC,CAAC,CAAC,aAAa,CAAC,mBAAmB,CAAC;YACzC,gBAAgB,EAAE,aAAa,CAAC,gBAAgB;YAChD,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,SAAS;YACnC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,OAAO;YAC9B,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,IAAI;SACzB,CAAC,CAAC;QAEH,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,MAAM,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC;CACF;AAED;;;;;;GAMG;AACH,SAAS,gBAAgB,CACvB,OAAmC,EACnC,IAAwB;IAExB,MAAM,OAAO,GAAG,GAAG,IAAI,CAAC,EAAE,gCAAgC,OAAO,CAAC,MAAM,EAAE,CAAC;IAE3E,OAAO,OAAO,CAAC,IAAI,KAAK,UAAU;QAChC,CAAC,CAAC,IAAI,+CAA+C,CAAC,OAAO,CAAC;QAC9D,CAAC,CAAC,IAAI,sCAAsC,CAAC,OAAO,CAAC,CAAC;AAC1D,CAAC"}

package/dist/service/cognito/user-pool/message/sim-cognito-pool-messenger.d.ts

@@ -1,13 +1,21 @@
 import type { SimClock } from "../../../../util/clock/sim-clock.js";
+import type { SimAwsMessageLog } from "../../../aws/message/sim-aws-message-log.js";
 import type { SimCognitoUserPoolClient } from "../client/sim-cognito-user-pool-client.js";
 import type { SimCognitoUserPool } from "../sim-cognito-user-pool.js";
 import type { SimCognitoUserPoolTriggers } from "../trigger/sim-cognito-user-pool-triggers.js";
 import type { SimCognitoUser } from "../user/sim-cognito-user.js";
 import { SimCognitoMessageDelivery } from "./sim-cognito-message-delivery.js";
 import type { SimCognitoMessageOccasion } from "./sim-cognito-message-occasion.js";
+import type { SimCognitoPoolEmailDelivery } from "./sim-cognito-pool-email-delivery.js";
 interface SimCognitoPoolMessengerProperties {
     readonly triggers: SimCognitoUserPoolTriggers;
+    /**
+     * Where a message goes before it is recorded, which for a pool sending
+     * through SES is the account's SES.
+     */
+    readonly email: SimCognitoPoolEmailDelivery;
     readonly clock: SimClock;
+    readonly messageLog: SimAwsMessageLog;
 }
 /**
  * What a pool is about to send.
@@ -32,14 +40,21 @@ interface SimCognitoMessageRequest {
  * reads it back off the pool, which is what makes a verification message
  * something a test can assert about at all.
  *
- * This is Cognito's own delivery, not SES. Real Cognito with the default
- * `EmailSendingAccount` of `COGNITO_DEFAULT` sends through no other service,
- * and `EmailConfiguration` is refused here, so no pool is configured for one
- * that would.
+ * A pool sending its own email stops there. Real Cognito with the default
+ * `EmailSendingAccount` of `COGNITO_DEFAULT` reaches no other service, so the
+ * record is the whole of what happened.
+ *
+ * A pool whose `EmailConfiguration` named `DEVELOPER` sends through the
+ * account's SES first, and records the message only once SES has taken it.
+ * The record and `sesV2().sentEmails()` then agree with each other, and a
+ * sign-up against a pool SES would refuse fails here as it would in a
+ * deployment.
  */
 export declare class SimCognitoPoolMessenger {
     private readonly triggers;
+    private readonly email;
     private readonly clock;
+    private readonly messageLog;
     constructor(properties: SimCognitoPoolMessengerProperties);
     /**
      * Send the message this occasion produces, running the pool's