raindancers-cloudfront 0.0.42 → 0.0.44

package/lib/cloudfront/patterns/cognitoCustomerPool.d.ts

@@ -19,6 +19,29 @@ export interface CognitoAppClientSpec {
     /** Generate a client secret. @default false (public SPA client) */
     readonly generateSecret?: boolean;
 }
+/**
+ * Same-account SES email configuration for the pool. Synthesises an
+ * `EmailConfiguration` with `EmailSendingAccount: DEVELOPER`. Its purpose is to
+ * satisfy Cognito's precondition for enabling EMAIL_OTP MFA — Cognito requires a
+ * verified same-account SES identity on the pool before it will accept
+ * `EnabledMfas: ['EMAIL_OTP']`, independently of any custom email sender that
+ * overrides actual delivery.
+ */
+export interface CognitoCustomerPoolEmailConfig {
+    /**
+     * ARN of a VERIFIED SES identity in the POOL's OWN account (domain identity
+     * preferred; a verified email-address identity also works). Passed to Cognito as
+     * the `EmailConfiguration.SourceArn`. Must be in the pool's region.
+     */
+    readonly sesVerifiedDomainArn: string;
+    /**
+     * The From address for the pool's SES configuration, e.g.
+     * `2fa@alpha.functionalself.com`. A local-part on the verified identity's domain.
+     */
+    readonly fromEmail: string;
+    /** Optional display name, e.g. "Functional Self". @default - address only */
+    readonly fromName?: string;
+}
 /**
  * Optional Cognito Identity Pool + ABAC (attributes-for-access-control) config.
  * Maps token claims to principal tags so downstream IAM can scope on them.
@@ -89,6 +112,29 @@ export interface CognitoCustomerPoolProps {
      * @default false
      */
     readonly emailOtpMfa?: boolean;
+    /**
+     * Configure the pool for PASSWORDLESS customer sign-in using choice-based
+     * authentication (`USER_AUTH`) with `EMAIL_OTP` as a first auth factor. The
+     * customer signs in with just their email and a one-time code — no password and
+     * no second factor. Delivered by {@link customEmailSenderLambda}; requires
+     * {@link customSenderKmsKey} and {@link emailConfiguration} (same enablement
+     * precondition as {@link emailOtpMfa}), and an Essentials-or-higher feature plan.
+     *
+     * Hard Cognito constraints this mode encodes (proven against a live pool):
+     * - `PASSWORD` is MANDATORY in `AllowedFirstAuthFactors`; Cognito rejects a list
+     *   without it. So the pool allows `[PASSWORD, EMAIL_OTP]` and the CONSUMER's UI
+     *   must never offer the password path (always `InitiateAuth(USER_AUTH,
+     *   PREFERRED_CHALLENGE=EMAIL_OTP)`). To keep the password unreachable through the
+     *   app client too, this mode also drops the `userSrp` auth flow and enables the
+     *   `user` (choice-based `ALLOW_USER_AUTH`) flow on the app clients.
+     * - `EMAIL_OTP` as a first factor is INCOMPATIBLE with `MfaConfiguration: ON`, so
+     *   this mode forces `mfa: OFF`. NOTE: the `OFF -> ON` transition is irreversible
+     *   via the API, so a pool created with this mode cannot later gain MFA in place.
+     *
+     * Mutually exclusive with {@link emailOtpMfa} (email is a first factor here, a
+     * second factor there). @default false
+     */
+    readonly passwordlessEmailOtp?: boolean;
     /**
      * Custom Email Sender Lambda. When set (together with {@link customSenderKmsKey}),
      * it is wired to the pool via the `CUSTOM_EMAIL_SENDER` trigger and Cognito
@@ -106,6 +152,22 @@ export interface CognitoCustomerPoolProps {
      * @default - no key (only valid when no custom email sender is set)
      */
     readonly customSenderKmsKey?: kms.IKey;
+    /**
+     * Same-account SES email configuration for the pool. REQUIRED when
+     * {@link emailOtpMfa} is set: Cognito refuses to enable EMAIL_OTP MFA unless the
+     * pool carries an `EmailSendingAccount: DEVELOPER` configuration pointing at a
+     * VERIFIED SES identity in the pool's OWN account — this precondition is validated
+     * at the pool-config layer, BEFORE any email is routed, so a
+     * {@link customEmailSenderLambda} (which overrides delivery) does not satisfy it.
+     *
+     * The identity here exists only to satisfy that enablement precondition; when a
+     * custom email sender is attached, Cognito never actually sends through this
+     * identity (the Lambda intercepts every email), so a cross-account or
+     * SES-sandbox delivery path is unaffected. Prefer a verified DOMAIN identity;
+     * a verified email-address identity also works if Cognito rejects the domain form.
+     * @default - no SES config (Cognito default sender; not valid with emailOtpMfa)
+     */
+    readonly emailConfiguration?: CognitoCustomerPoolEmailConfig;
     /**
      * L1 account-takeover risk configuration (requires {@link advancedSecurityMode}
      * ENFORCED/AUDIT). Passed through to CfnUserPoolRiskConfigurationAttachment.

package/lib/cloudfront/patterns/cognitoCustomerPool.js

@@ -62,27 +62,50 @@ class CognitoCustomerPool extends constructs.Construct {
             throw new Error('CognitoCustomerPool: emailOtpMfa requires customEmailSenderLambda (and customSenderKmsKey) — '
                 + 'EMAIL_OTP codes are delivered by the custom email sender, so email MFA cannot be enabled without it.');
         }
+        if (props.emailOtpMfa && !props.emailConfiguration) {
+            throw new Error('CognitoCustomerPool: emailOtpMfa requires emailConfiguration — '
+                + 'Cognito refuses to enable EMAIL_OTP MFA unless the pool carries a DEVELOPER SES '
+                + 'EmailConfiguration on a verified same-account identity. This precondition is checked '
+                + 'before any email is routed, so the custom email sender does not satisfy it.');
+        }
+        if (props.passwordlessEmailOtp && props.emailOtpMfa) {
+            throw new Error('CognitoCustomerPool: passwordlessEmailOtp and emailOtpMfa are mutually exclusive — '
+                + 'passwordless uses EMAIL_OTP as a FIRST auth factor (MFA off), while emailOtpMfa uses it '
+                + 'as a SECOND factor (MFA on). Choose one.');
+        }
+        if (props.passwordlessEmailOtp && (!props.customEmailSenderLambda || !props.emailConfiguration)) {
+            throw new Error('CognitoCustomerPool: passwordlessEmailOtp requires customEmailSenderLambda, customSenderKmsKey '
+                + 'and emailConfiguration — the first-factor EMAIL_OTP code is delivered by the custom email '
+                + 'sender, and Cognito requires the same DEVELOPER SES EmailConfiguration enablement precondition.');
+        }
         // With emailOtpMfa, EMAIL_OTP is the sole factor and is applied via an L1
         // override below; do NOT pass mfaSecondFactor.email to the L2 (its validateEmailMfa
-        // demands a managed DEVELOPER SES config, which the custom-sender path avoids).
+        // demands a `email` UserPoolEmail be set, which we supply separately via
+        // emailConfiguration — see the `email` prop below).
         const l2MfaSecondFactor = props.emailOtpMfa
             ? { otp: false, sms: false }
             : (props.mfaSecondFactor ?? { otp: true, sms: false });
-        // Account recovery must not be email-only when EMAIL_OTP MFA is enabled:
-        // Cognito rejects EmailMfaConfiguration unless AccountRecoverySetting has at
-        // least one mechanism other than verified_email (recovering email-based MFA via
-        // email is circular). AccountRecovery.NONE maps to the admin_only mechanism, which
-        // satisfies the constraint without introducing an SMS/phone factor into this
-        // passwordless-email design. Otherwise keep the email-only default.
         const accountRecovery = props.emailOtpMfa
+            // Cognito rejects EmailMfaConfiguration unless AccountRecoverySetting has at
+            // least one mechanism other than verified_email (recovering email-based MFA via
+            // email is circular). AccountRecovery.NONE maps to the admin_only mechanism, which
+            // satisfies the constraint without introducing an SMS/phone factor into this
+            // passwordless-email design. Otherwise keep the email-only default.
             ? aws_cdk_lib_1.aws_cognito.AccountRecovery.NONE
             : aws_cdk_lib_1.aws_cognito.AccountRecovery.EMAIL_ONLY;
+        // Passwordless uses EMAIL_OTP as a FIRST auth factor, which Cognito forbids while
+        // MFA is ON ("Only PASSWORD and WEB_AUTHN can be enabled as an auth factor if MFA
+        // is enabled"). So passwordless forces MFA OFF. NB: the OFF->ON transition is
+        // irreversible via the API — a pool created passwordless cannot later gain MFA in place.
+        const mfaConfig = props.passwordlessEmailOtp
+            ? aws_cdk_lib_1.aws_cognito.Mfa.OFF
+            : (props.mfa ?? aws_cdk_lib_1.aws_cognito.Mfa.REQUIRED);
         this.userPool = new aws_cdk_lib_1.aws_cognito.UserPool(this, 'UserPool', {
             userPoolName: props.userPoolName,
             selfSignUpEnabled: props.selfSignUpEnabled ?? false,
             signInAliases: { email: true },
             signInCaseSensitive: false,
-            mfa: props.mfa ?? aws_cdk_lib_1.aws_cognito.Mfa.REQUIRED,
+            mfa: mfaConfig,
             mfaSecondFactor: l2MfaSecondFactor,
             passwordPolicy: props.passwordPolicy ?? {
                 minLength: 12,
@@ -108,11 +131,38 @@ class CognitoCustomerPool extends constructs.Construct {
         // L1 escape hatch: enable EMAIL_OTP as the only MFA factor. The L2 cannot express
         // "email MFA delivered solely by a custom sender" (see emailOtpMfa docs), so set
         // EnabledMfas directly on the underlying CfnUserPool. The custom email sender
-        // delivers the code; no managed SES email configuration is required.
+        // delivers the code, but Cognito still requires a DEVELOPER SES EmailConfiguration
+        // on a verified same-account identity as an ENABLEMENT precondition (below).
+        if (props.emailConfiguration) {
+            // Set EmailConfiguration via L1 with the caller's exact verified same-account
+            // identity ARN — accepting either a domain or an email-address identity without
+            // CDK re-deriving the ARN from the From address. This satisfies Cognito's
+            // EMAIL_OTP enablement precondition; the custom email sender still overrides
+            // actual delivery, so this identity is never sent through.
+            const cfnPool = this.userPool.node.defaultChild;
+            cfnPool.emailConfiguration = {
+                emailSendingAccount: 'DEVELOPER',
+                sourceArn: props.emailConfiguration.sesVerifiedDomainArn,
+                from: props.emailConfiguration.fromName
+                    ? `${props.emailConfiguration.fromName} <${props.emailConfiguration.fromEmail}>`
+                    : props.emailConfiguration.fromEmail,
+            };
+        }
         if (props.emailOtpMfa) {
             const cfnPool = this.userPool.node.defaultChild;
             cfnPool.enabledMfas = ['EMAIL_OTP'];
         }
+        if (props.passwordlessEmailOtp) {
+            // Choice-based sign-in: EMAIL_OTP as a first auth factor. PASSWORD is MANDATORY
+            // in AllowedFirstAuthFactors (Cognito rejects a list without it), so it stays —
+            // but the app client below drops the password (userSrp) flow and the consumer's
+            // UI never offers it, so the password path is unreachable through this client.
+            const cfnPool = this.userPool.node.defaultChild;
+            cfnPool.policies = {
+                ...cfnPool.policies,
+                signInPolicy: { allowedFirstAuthFactors: ['PASSWORD', 'EMAIL_OTP'] },
+            };
+        }
         const preTokenLambda = props.preTokenGenerationLambda ?? new aws_cdk_lib_1.aws_lambda.Function(this, 'PreTokenLambda', {
             runtime: aws_cdk_lib_1.aws_lambda.Runtime.PYTHON_3_12,
             handler: 'index.handler',
@@ -142,11 +192,20 @@ class CognitoCustomerPool extends constructs.Construct {
             const client = new aws_cdk_lib_1.aws_cognito.UserPoolClient(this, `Client${spec.key}`, {
                 userPool: this.userPool,
                 generateSecret: spec.generateSecret ?? false,
-                authFlows: {
-                    userSrp: true,
-                    custom: props.enableCustomAuthFlow ?? false,
-                    // userPassword / adminUserPassword intentionally omitted (disabled).
-                },
+                authFlows: props.passwordlessEmailOtp
+                    ? {
+                        // Passwordless: enable choice-based ALLOW_USER_AUTH and DROP userSrp so the
+                        // password challenge cannot be initiated through this client — even by a
+                        // direct API call. PASSWORD stays a pool factor (Cognito's rule) but is
+                        // unreachable via the storefront client.
+                        user: true,
+                        custom: props.enableCustomAuthFlow ?? false,
+                    }
+                    : {
+                        userSrp: true,
+                        custom: props.enableCustomAuthFlow ?? false,
+                        // userPassword / adminUserPassword intentionally omitted (disabled).
+                    },
                 oAuth: {
                     flows: { authorizationCodeGrant: true },
                     scopes: [aws_cdk_lib_1.aws_cognito.OAuthScope.OPENID, aws_cdk_lib_1.aws_cognito.OAuthScope.EMAIL, aws_cdk_lib_1.aws_cognito.OAuthScope.PROFILE],
@@ -201,4 +260,4 @@ class CognitoCustomerPool extends constructs.Construct {
     }
 }
 exports.CognitoCustomerPool = CognitoCustomerPool;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cognitoCustomerPool.js","sourceRoot":"","sources":["../../../src/cloudfront/patterns/cognitoCustomerPool.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as core from 'aws-cdk-lib';\nimport {\n  aws_cognito as cognito,\n  aws_iam as iam,\n  aws_kms as kms,\n  aws_lambda as lambda,\n} from 'aws-cdk-lib';\nimport * as constructs from 'constructs';\n\ntype AccountTakeoverRiskConfig = cognito.CfnUserPoolRiskConfigurationAttachment.AccountTakeoverRiskConfigurationTypeProperty;\ntype CompromisedCredentialsRiskConfig = cognito.CfnUserPoolRiskConfigurationAttachment.CompromisedCredentialsRiskConfigurationTypeProperty;\n\n/**\n * Specification for one Cognito app client (e.g. one brand or one front-end).\n * Public SPA clients: no secret, PKCE (authorization-code grant), SRP.\n */\nexport interface CognitoAppClientSpec {\n  /** Logical key used as the construct id and the key in {@link CognitoCustomerPool.userPoolClients}. */\n  readonly key: string;\n  /** OAuth2 callback URLs for this client (used only by the social/hosted redirect flow). */\n  readonly callbackUrls?: string[];\n  /** Logout URLs for this client. */\n  readonly logoutUrls?: string[];\n  /** Identity providers this client supports. @default [COGNITO] */\n  readonly supportedIdentityProviders?: cognito.UserPoolClientIdentityProvider[];\n  /** Generate a client secret. @default false (public SPA client) */\n  readonly generateSecret?: boolean;\n}\n\n/**\n * Optional Cognito Identity Pool + ABAC (attributes-for-access-control) config.\n * Maps token claims to principal tags so downstream IAM can scope on them.\n */\nexport interface CognitoIdentityPoolAbacConfig {\n  /** Allow unauthenticated (guest) identities. @default false */\n  readonly allowUnauthenticatedIdentities?: boolean;\n  /**\n   * Claim → principal-tag mapping, e.g. `{ sub: 'customer-id' }`. Applied to the\n   * user-pool provider so authenticated sessions carry these as `aws:PrincipalTag/*`.\n   */\n  readonly principalTags?: Record<string, string>;\n  /** Managed policies for the authenticated role. @default none (attach your own). */\n  readonly authenticatedRoleManagedPolicies?: iam.IManagedPolicy[];\n}\n\n/**\n * Props for {@link CognitoCustomerPool}. Every value is generic — no\n * project/brand/domain specifics are baked in; pass them here.\n */\nexport interface CognitoCustomerPoolProps {\n  /** User pool name. */\n  readonly userPoolName?: string;\n  /** Cognito hosted-UI domain prefix (globally unique). */\n  readonly cognitoDomainPrefix: string;\n  /** App clients to create (typically one per brand/front-end). At least one. */\n  readonly appClients: CognitoAppClientSpec[];\n  /** Enable self-service sign-up. @default false */\n  readonly selfSignUpEnabled?: boolean;\n  /** MFA enforcement. @default REQUIRED */\n  readonly mfa?: cognito.Mfa;\n  /** Second factors. @default { otp: true, sms: false } */\n  readonly mfaSecondFactor?: cognito.MfaSecondFactor;\n  /** Password policy. @default minLength 12, upper/lower/digits/symbols. */\n  readonly passwordPolicy?: cognito.PasswordPolicy;\n  /** Advanced security mode (threat protection). @default OFF */\n  readonly advancedSecurityMode?: cognito.AdvancedSecurityMode;\n  /** Standard attributes config. */\n  readonly standardAttributes?: cognito.StandardAttributes;\n  /** Custom attributes. */\n  readonly customAttributes?: { [key: string]: cognito.ICustomAttribute };\n  /** Enable the CUSTOM_AUTH flow on app clients. @default false */\n  readonly enableCustomAuthFlow?: boolean;\n  /** Access token validity. @default 1 hour */\n  readonly accessTokenValidity?: core.Duration;\n  /** ID token validity. @default 1 hour */\n  readonly idTokenValidity?: core.Duration;\n  /** Refresh token validity. @default 30 days */\n  readonly refreshTokenValidity?: core.Duration;\n  /** Cognito groups to create. */\n  readonly groups?: string[];\n  /**\n   * Pre-token-generation Lambda (V2). @default a bundled no-op library Lambda is\n   * created. Pass your own to customise emitted claims.\n   */\n  readonly preTokenGenerationLambda?: lambda.IFunction;\n  /**\n   * Enable email one-time-password (`EMAIL_OTP`) as the MFA second factor, delivered\n   * by {@link customEmailSenderLambda}. This is set via an L1 override on the\n   * underlying `CfnUserPool` (`EnabledMfas: ['EMAIL_OTP']`) rather than\n   * `mfaSecondFactor.email`, because the CDK L2 requires a managed (`DEVELOPER`) SES\n   * `email` config for `mfaSecondFactor.email` — which is incompatible with a\n   * custom-email-sender-only delivery path. Requires {@link customEmailSenderLambda}\n   * and {@link customSenderKmsKey}, and a pool feature plan of Essentials or higher.\n   * When true, any `otp`/`sms` in {@link mfaSecondFactor} is ignored — EMAIL_OTP is\n   * the sole factor.\n   * @default false\n   */\n  readonly emailOtpMfa?: boolean;\n  /**\n   * Custom Email Sender Lambda. When set (together with {@link customSenderKmsKey}),\n   * it is wired to the pool via the `CUSTOM_EMAIL_SENDER` trigger and Cognito\n   * delivers all customer emails (MFA codes, verification, temporary passwords)\n   * through this Lambda instead of its default sender or a managed SES sender.\n   * Cognito encrypts each code to {@link customSenderKmsKey}; the Lambda decrypts\n   * it with the AWS Encryption SDK before sending. Requires {@link customSenderKmsKey}.\n   * @default - Cognito's default email delivery\n   */\n  readonly customEmailSenderLambda?: lambda.IFunction;\n  /**\n   * Symmetric KMS key Cognito uses to encrypt codes for {@link customEmailSenderLambda}.\n   * Required when a custom email sender is provided; ignored otherwise. Cognito is\n   * granted encrypt/decrypt on it; the Lambda must be separately granted decrypt.\n   * @default - no key (only valid when no custom email sender is set)\n   */\n  readonly customSenderKmsKey?: kms.IKey;\n  /**\n   * L1 account-takeover risk configuration (requires {@link advancedSecurityMode}\n   * ENFORCED/AUDIT). Passed through to CfnUserPoolRiskConfigurationAttachment.\n   */\n  readonly accountTakeoverRiskConfiguration?: AccountTakeoverRiskConfig;\n  /** L1 compromised-credentials risk configuration. */\n  readonly compromisedCredentialsRiskConfiguration?: CompromisedCredentialsRiskConfig;\n  /** Optional identity pool + ABAC configuration. */\n  readonly identityPool?: CognitoIdentityPoolAbacConfig;\n  /** Removal policy for the pool. @default RETAIN */\n  readonly removalPolicy?: core.RemovalPolicy;\n}\n\n/**\n * A generic, reusable secure Cognito **customer** user pool for the custom-UI\n * (client-side SRP) authentication pattern: public PKCE app clients, MFA,\n * strong password policy, optional advanced-security threat protection,\n * per-client (per-brand) app clients, and an optional identity pool with ABAC.\n *\n * Provisions ONLY the identity provider. It knows nothing about CloudFront,\n * sessions, or any specific project — pair it with `CognitoSessionBackend`\n * (session substrate) and `CognitoCustomUiAuth` (edge/CDN).\n */\nexport class CognitoCustomerPool extends constructs.Construct {\n  public readonly userPool: cognito.UserPool;\n  /** App clients keyed by {@link CognitoAppClientSpec.key}. */\n  public readonly userPoolClients: Record<string, cognito.UserPoolClient>;\n  /** The first app client, for convenience. */\n  public readonly userPoolClient: cognito.UserPoolClient;\n  public readonly userPoolDomain: cognito.UserPoolDomain;\n  /** Hosted-UI domain URL, e.g. `<prefix>.auth.<region>.amazoncognito.com`. */\n  public readonly cognitoDomainUrl: string;\n  public readonly identityPool?: cognito.CfnIdentityPool;\n  public readonly authenticatedRole?: iam.Role;\n\n  constructor(scope: constructs.Construct, id: string, props: CognitoCustomerPoolProps) {\n    super(scope, id);\n\n    if (!props.appClients || props.appClients.length === 0) {\n      throw new Error('CognitoCustomerPool requires at least one app client');\n    }\n\n    if ((props.customEmailSenderLambda === undefined) !== (props.customSenderKmsKey === undefined)) {\n      throw new Error(\n        'CognitoCustomerPool: customEmailSenderLambda and customSenderKmsKey must be provided together — '\n        + 'a custom email sender requires a KMS key for Cognito to encrypt codes to, and the key is unused without the Lambda.',\n      );\n    }\n\n    if (props.emailOtpMfa && !props.customEmailSenderLambda) {\n      throw new Error(\n        'CognitoCustomerPool: emailOtpMfa requires customEmailSenderLambda (and customSenderKmsKey) — '\n        + 'EMAIL_OTP codes are delivered by the custom email sender, so email MFA cannot be enabled without it.',\n      );\n    }\n\n    // With emailOtpMfa, EMAIL_OTP is the sole factor and is applied via an L1\n    // override below; do NOT pass mfaSecondFactor.email to the L2 (its validateEmailMfa\n    // demands a managed DEVELOPER SES config, which the custom-sender path avoids).\n    const l2MfaSecondFactor = props.emailOtpMfa\n      ? { otp: false, sms: false }\n      : (props.mfaSecondFactor ?? { otp: true, sms: false });\n\n    // Account recovery must not be email-only when EMAIL_OTP MFA is enabled:\n    // Cognito rejects EmailMfaConfiguration unless AccountRecoverySetting has at\n    // least one mechanism other than verified_email (recovering email-based MFA via\n    // email is circular). AccountRecovery.NONE maps to the admin_only mechanism, which\n    // satisfies the constraint without introducing an SMS/phone factor into this\n    // passwordless-email design. Otherwise keep the email-only default.\n    const accountRecovery = props.emailOtpMfa\n      ? cognito.AccountRecovery.NONE\n      : cognito.AccountRecovery.EMAIL_ONLY;\n\n    this.userPool = new cognito.UserPool(this, 'UserPool', {\n      userPoolName: props.userPoolName,\n      selfSignUpEnabled: props.selfSignUpEnabled ?? false,\n      signInAliases: { email: true },\n      signInCaseSensitive: false,\n      mfa: props.mfa ?? cognito.Mfa.REQUIRED,\n      mfaSecondFactor: l2MfaSecondFactor,\n      passwordPolicy: props.passwordPolicy ?? {\n        minLength: 12,\n        requireLowercase: true,\n        requireUppercase: true,\n        requireDigits: true,\n        requireSymbols: true,\n      },\n      advancedSecurityMode: props.advancedSecurityMode ?? cognito.AdvancedSecurityMode.OFF,\n      standardAttributes: props.standardAttributes,\n      customAttributes: props.customAttributes,\n      autoVerify: { email: true },\n      accountRecovery,\n      // Custom Email Sender: when provided, Cognito routes every customer email\n      // through this Lambda and encrypts codes to customSenderKmsKey. Both must be\n      // set on the pool at construction — the KMS key is not settable via addTrigger.\n      customSenderKmsKey: props.customSenderKmsKey,\n      lambdaTriggers: props.customEmailSenderLambda\n        ? { customEmailSender: props.customEmailSenderLambda }\n        : undefined,\n      removalPolicy: props.removalPolicy ?? core.RemovalPolicy.RETAIN,\n    });\n\n    // L1 escape hatch: enable EMAIL_OTP as the only MFA factor. The L2 cannot express\n    // \"email MFA delivered solely by a custom sender\" (see emailOtpMfa docs), so set\n    // EnabledMfas directly on the underlying CfnUserPool. The custom email sender\n    // delivers the code; no managed SES email configuration is required.\n    if (props.emailOtpMfa) {\n      const cfnPool = this.userPool.node.defaultChild as cognito.CfnUserPool;\n      cfnPool.enabledMfas = ['EMAIL_OTP'];\n    }\n\n    const preTokenLambda = props.preTokenGenerationLambda ?? new lambda.Function(this, 'PreTokenLambda', {\n      runtime: lambda.Runtime.PYTHON_3_12,\n      handler: 'index.handler',\n      code: lambda.Code.fromAsset(path.join(__dirname, '../lambda/pre-token')),\n      timeout: core.Duration.seconds(5),\n    });\n    this.userPool.addTrigger(cognito.UserPoolOperation.PRE_TOKEN_GENERATION_CONFIG, preTokenLambda, cognito.LambdaVersion.V2_0);\n\n    if (props.groups) {\n      for (const group of props.groups) {\n        new cognito.CfnUserPoolGroup(this, `Group${group}`, {\n          userPoolId: this.userPool.userPoolId,\n          groupName: group,\n        });\n      }\n    }\n\n    // Optional advanced-security risk configuration (L1).\n    if (props.accountTakeoverRiskConfiguration || props.compromisedCredentialsRiskConfiguration) {\n      new cognito.CfnUserPoolRiskConfigurationAttachment(this, 'RiskConfig', {\n        userPoolId: this.userPool.userPoolId,\n        clientId: 'ALL',\n        accountTakeoverRiskConfiguration: props.accountTakeoverRiskConfiguration,\n        compromisedCredentialsRiskConfiguration: props.compromisedCredentialsRiskConfiguration,\n      });\n    }\n\n    this.userPoolClients = {};\n    for (const spec of props.appClients) {\n      const client = new cognito.UserPoolClient(this, `Client${spec.key}`, {\n        userPool: this.userPool,\n        generateSecret: spec.generateSecret ?? false,\n        authFlows: {\n          userSrp: true,\n          custom: props.enableCustomAuthFlow ?? false,\n          // userPassword / adminUserPassword intentionally omitted (disabled).\n        },\n        oAuth: {\n          flows: { authorizationCodeGrant: true },\n          scopes: [cognito.OAuthScope.OPENID, cognito.OAuthScope.EMAIL, cognito.OAuthScope.PROFILE],\n          callbackUrls: spec.callbackUrls,\n          logoutUrls: spec.logoutUrls,\n        },\n        supportedIdentityProviders: spec.supportedIdentityProviders ?? [cognito.UserPoolClientIdentityProvider.COGNITO],\n        preventUserExistenceErrors: true,\n        enableTokenRevocation: true,\n        accessTokenValidity: props.accessTokenValidity ?? core.Duration.hours(1),\n        idTokenValidity: props.idTokenValidity ?? core.Duration.hours(1),\n        refreshTokenValidity: props.refreshTokenValidity ?? core.Duration.days(30),\n      });\n      this.userPoolClients[spec.key] = client;\n    }\n    this.userPoolClient = this.userPoolClients[props.appClients[0].key];\n\n    this.userPoolDomain = this.userPool.addDomain('CognitoDomain', {\n      cognitoDomain: { domainPrefix: props.cognitoDomainPrefix },\n    });\n    this.cognitoDomainUrl = `${props.cognitoDomainPrefix}.auth.${core.Stack.of(this).region}.amazoncognito.com`;\n\n    if (props.identityPool) {\n      const idp = props.identityPool;\n      this.identityPool = new cognito.CfnIdentityPool(this, 'IdentityPool', {\n        allowUnauthenticatedIdentities: idp.allowUnauthenticatedIdentities ?? false,\n        cognitoIdentityProviders: props.appClients.map(spec => ({\n          clientId: this.userPoolClients[spec.key].userPoolClientId,\n          providerName: this.userPool.userPoolProviderName,\n          serverSideTokenCheck: true,\n        })),\n      });\n\n      this.authenticatedRole = new iam.Role(this, 'AuthenticatedRole', {\n        assumedBy: new iam.FederatedPrincipal(\n          'cognito-identity.amazonaws.com',\n          {\n            'StringEquals': { 'cognito-identity.amazonaws.com:aud': this.identityPool.ref },\n            'ForAnyValue:StringLike': { 'cognito-identity.amazonaws.com:amr': 'authenticated' },\n          },\n          'sts:AssumeRoleWithWebIdentity',\n        ),\n        managedPolicies: idp.authenticatedRoleManagedPolicies,\n      });\n\n      new cognito.CfnIdentityPoolRoleAttachment(this, 'IdentityPoolRoles', {\n        identityPoolId: this.identityPool.ref,\n        roles: { authenticated: this.authenticatedRole.roleArn },\n      });\n\n      // ABAC: map claims to principal tags on the user-pool provider.\n      if (idp.principalTags && Object.keys(idp.principalTags).length > 0) {\n        new cognito.CfnIdentityPoolPrincipalTag(this, 'PrincipalTags', {\n          identityPoolId: this.identityPool.ref,\n          identityProviderName: this.userPool.userPoolProviderName,\n          useDefaults: false,\n          principalTags: idp.principalTags,\n        });\n      }\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cognitoCustomerPool.js","sourceRoot":"","sources":["../../../src/cloudfront/patterns/cognitoCustomerPool.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as core from 'aws-cdk-lib';\nimport {\n  aws_cognito as cognito,\n  aws_iam as iam,\n  aws_kms as kms,\n  aws_lambda as lambda,\n} from 'aws-cdk-lib';\nimport * as constructs from 'constructs';\n\ntype AccountTakeoverRiskConfig = cognito.CfnUserPoolRiskConfigurationAttachment.AccountTakeoverRiskConfigurationTypeProperty;\ntype CompromisedCredentialsRiskConfig = cognito.CfnUserPoolRiskConfigurationAttachment.CompromisedCredentialsRiskConfigurationTypeProperty;\n\n/**\n * Specification for one Cognito app client (e.g. one brand or one front-end).\n * Public SPA clients: no secret, PKCE (authorization-code grant), SRP.\n */\nexport interface CognitoAppClientSpec {\n  /** Logical key used as the construct id and the key in {@link CognitoCustomerPool.userPoolClients}. */\n  readonly key: string;\n  /** OAuth2 callback URLs for this client (used only by the social/hosted redirect flow). */\n  readonly callbackUrls?: string[];\n  /** Logout URLs for this client. */\n  readonly logoutUrls?: string[];\n  /** Identity providers this client supports. @default [COGNITO] */\n  readonly supportedIdentityProviders?: cognito.UserPoolClientIdentityProvider[];\n  /** Generate a client secret. @default false (public SPA client) */\n  readonly generateSecret?: boolean;\n}\n\n/**\n * Same-account SES email configuration for the pool. Synthesises an\n * `EmailConfiguration` with `EmailSendingAccount: DEVELOPER`. Its purpose is to\n * satisfy Cognito's precondition for enabling EMAIL_OTP MFA — Cognito requires a\n * verified same-account SES identity on the pool before it will accept\n * `EnabledMfas: ['EMAIL_OTP']`, independently of any custom email sender that\n * overrides actual delivery.\n */\nexport interface CognitoCustomerPoolEmailConfig {\n  /**\n   * ARN of a VERIFIED SES identity in the POOL's OWN account (domain identity\n   * preferred; a verified email-address identity also works). Passed to Cognito as\n   * the `EmailConfiguration.SourceArn`. Must be in the pool's region.\n   */\n  readonly sesVerifiedDomainArn: string;\n  /**\n   * The From address for the pool's SES configuration, e.g.\n   * `2fa@alpha.functionalself.com`. A local-part on the verified identity's domain.\n   */\n  readonly fromEmail: string;\n  /** Optional display name, e.g. \"Functional Self\". @default - address only */\n  readonly fromName?: string;\n}\n\n/**\n * Optional Cognito Identity Pool + ABAC (attributes-for-access-control) config.\n * Maps token claims to principal tags so downstream IAM can scope on them.\n */\nexport interface CognitoIdentityPoolAbacConfig {\n  /** Allow unauthenticated (guest) identities. @default false */\n  readonly allowUnauthenticatedIdentities?: boolean;\n  /**\n   * Claim → principal-tag mapping, e.g. `{ sub: 'customer-id' }`. Applied to the\n   * user-pool provider so authenticated sessions carry these as `aws:PrincipalTag/*`.\n   */\n  readonly principalTags?: Record<string, string>;\n  /** Managed policies for the authenticated role. @default none (attach your own). */\n  readonly authenticatedRoleManagedPolicies?: iam.IManagedPolicy[];\n}\n\n/**\n * Props for {@link CognitoCustomerPool}. Every value is generic — no\n * project/brand/domain specifics are baked in; pass them here.\n */\nexport interface CognitoCustomerPoolProps {\n  /** User pool name. */\n  readonly userPoolName?: string;\n  /** Cognito hosted-UI domain prefix (globally unique). */\n  readonly cognitoDomainPrefix: string;\n  /** App clients to create (typically one per brand/front-end). At least one. */\n  readonly appClients: CognitoAppClientSpec[];\n  /** Enable self-service sign-up. @default false */\n  readonly selfSignUpEnabled?: boolean;\n  /** MFA enforcement. @default REQUIRED */\n  readonly mfa?: cognito.Mfa;\n  /** Second factors. @default { otp: true, sms: false } */\n  readonly mfaSecondFactor?: cognito.MfaSecondFactor;\n  /** Password policy. @default minLength 12, upper/lower/digits/symbols. */\n  readonly passwordPolicy?: cognito.PasswordPolicy;\n  /** Advanced security mode (threat protection). @default OFF */\n  readonly advancedSecurityMode?: cognito.AdvancedSecurityMode;\n  /** Standard attributes config. */\n  readonly standardAttributes?: cognito.StandardAttributes;\n  /** Custom attributes. */\n  readonly customAttributes?: { [key: string]: cognito.ICustomAttribute };\n  /** Enable the CUSTOM_AUTH flow on app clients. @default false */\n  readonly enableCustomAuthFlow?: boolean;\n  /** Access token validity. @default 1 hour */\n  readonly accessTokenValidity?: core.Duration;\n  /** ID token validity. @default 1 hour */\n  readonly idTokenValidity?: core.Duration;\n  /** Refresh token validity. @default 30 days */\n  readonly refreshTokenValidity?: core.Duration;\n  /** Cognito groups to create. */\n  readonly groups?: string[];\n  /**\n   * Pre-token-generation Lambda (V2). @default a bundled no-op library Lambda is\n   * created. Pass your own to customise emitted claims.\n   */\n  readonly preTokenGenerationLambda?: lambda.IFunction;\n  /**\n   * Enable email one-time-password (`EMAIL_OTP`) as the MFA second factor, delivered\n   * by {@link customEmailSenderLambda}. This is set via an L1 override on the\n   * underlying `CfnUserPool` (`EnabledMfas: ['EMAIL_OTP']`) rather than\n   * `mfaSecondFactor.email`, because the CDK L2 requires a managed (`DEVELOPER`) SES\n   * `email` config for `mfaSecondFactor.email` — which is incompatible with a\n   * custom-email-sender-only delivery path. Requires {@link customEmailSenderLambda}\n   * and {@link customSenderKmsKey}, and a pool feature plan of Essentials or higher.\n   * When true, any `otp`/`sms` in {@link mfaSecondFactor} is ignored — EMAIL_OTP is\n   * the sole factor.\n   * @default false\n   */\n  readonly emailOtpMfa?: boolean;\n  /**\n   * Configure the pool for PASSWORDLESS customer sign-in using choice-based\n   * authentication (`USER_AUTH`) with `EMAIL_OTP` as a first auth factor. The\n   * customer signs in with just their email and a one-time code — no password and\n   * no second factor. Delivered by {@link customEmailSenderLambda}; requires\n   * {@link customSenderKmsKey} and {@link emailConfiguration} (same enablement\n   * precondition as {@link emailOtpMfa}), and an Essentials-or-higher feature plan.\n   *\n   * Hard Cognito constraints this mode encodes (proven against a live pool):\n   * - `PASSWORD` is MANDATORY in `AllowedFirstAuthFactors`; Cognito rejects a list\n   *   without it. So the pool allows `[PASSWORD, EMAIL_OTP]` and the CONSUMER's UI\n   *   must never offer the password path (always `InitiateAuth(USER_AUTH,\n   *   PREFERRED_CHALLENGE=EMAIL_OTP)`). To keep the password unreachable through the\n   *   app client too, this mode also drops the `userSrp` auth flow and enables the\n   *   `user` (choice-based `ALLOW_USER_AUTH`) flow on the app clients.\n   * - `EMAIL_OTP` as a first factor is INCOMPATIBLE with `MfaConfiguration: ON`, so\n   *   this mode forces `mfa: OFF`. NOTE: the `OFF -> ON` transition is irreversible\n   *   via the API, so a pool created with this mode cannot later gain MFA in place.\n   *\n   * Mutually exclusive with {@link emailOtpMfa} (email is a first factor here, a\n   * second factor there). @default false\n   */\n  readonly passwordlessEmailOtp?: boolean;\n  /**\n   * Custom Email Sender Lambda. When set (together with {@link customSenderKmsKey}),\n   * it is wired to the pool via the `CUSTOM_EMAIL_SENDER` trigger and Cognito\n   * delivers all customer emails (MFA codes, verification, temporary passwords)\n   * through this Lambda instead of its default sender or a managed SES sender.\n   * Cognito encrypts each code to {@link customSenderKmsKey}; the Lambda decrypts\n   * it with the AWS Encryption SDK before sending. Requires {@link customSenderKmsKey}.\n   * @default - Cognito's default email delivery\n   */\n  readonly customEmailSenderLambda?: lambda.IFunction;\n  /**\n   * Symmetric KMS key Cognito uses to encrypt codes for {@link customEmailSenderLambda}.\n   * Required when a custom email sender is provided; ignored otherwise. Cognito is\n   * granted encrypt/decrypt on it; the Lambda must be separately granted decrypt.\n   * @default - no key (only valid when no custom email sender is set)\n   */\n  readonly customSenderKmsKey?: kms.IKey;\n  /**\n   * Same-account SES email configuration for the pool. REQUIRED when\n   * {@link emailOtpMfa} is set: Cognito refuses to enable EMAIL_OTP MFA unless the\n   * pool carries an `EmailSendingAccount: DEVELOPER` configuration pointing at a\n   * VERIFIED SES identity in the pool's OWN account — this precondition is validated\n   * at the pool-config layer, BEFORE any email is routed, so a\n   * {@link customEmailSenderLambda} (which overrides delivery) does not satisfy it.\n   *\n   * The identity here exists only to satisfy that enablement precondition; when a\n   * custom email sender is attached, Cognito never actually sends through this\n   * identity (the Lambda intercepts every email), so a cross-account or\n   * SES-sandbox delivery path is unaffected. Prefer a verified DOMAIN identity;\n   * a verified email-address identity also works if Cognito rejects the domain form.\n   * @default - no SES config (Cognito default sender; not valid with emailOtpMfa)\n   */\n  readonly emailConfiguration?: CognitoCustomerPoolEmailConfig;\n  /**\n   * L1 account-takeover risk configuration (requires {@link advancedSecurityMode}\n   * ENFORCED/AUDIT). Passed through to CfnUserPoolRiskConfigurationAttachment.\n   */\n  readonly accountTakeoverRiskConfiguration?: AccountTakeoverRiskConfig;\n  /** L1 compromised-credentials risk configuration. */\n  readonly compromisedCredentialsRiskConfiguration?: CompromisedCredentialsRiskConfig;\n  /** Optional identity pool + ABAC configuration. */\n  readonly identityPool?: CognitoIdentityPoolAbacConfig;\n  /** Removal policy for the pool. @default RETAIN */\n  readonly removalPolicy?: core.RemovalPolicy;\n}\n\n/**\n * A generic, reusable secure Cognito **customer** user pool for the custom-UI\n * (client-side SRP) authentication pattern: public PKCE app clients, MFA,\n * strong password policy, optional advanced-security threat protection,\n * per-client (per-brand) app clients, and an optional identity pool with ABAC.\n *\n * Provisions ONLY the identity provider. It knows nothing about CloudFront,\n * sessions, or any specific project — pair it with `CognitoSessionBackend`\n * (session substrate) and `CognitoCustomUiAuth` (edge/CDN).\n */\nexport class CognitoCustomerPool extends constructs.Construct {\n  public readonly userPool: cognito.UserPool;\n  /** App clients keyed by {@link CognitoAppClientSpec.key}. */\n  public readonly userPoolClients: Record<string, cognito.UserPoolClient>;\n  /** The first app client, for convenience. */\n  public readonly userPoolClient: cognito.UserPoolClient;\n  public readonly userPoolDomain: cognito.UserPoolDomain;\n  /** Hosted-UI domain URL, e.g. `<prefix>.auth.<region>.amazoncognito.com`. */\n  public readonly cognitoDomainUrl: string;\n  public readonly identityPool?: cognito.CfnIdentityPool;\n  public readonly authenticatedRole?: iam.Role;\n\n  constructor(scope: constructs.Construct, id: string, props: CognitoCustomerPoolProps) {\n    super(scope, id);\n\n    if (!props.appClients || props.appClients.length === 0) {\n      throw new Error('CognitoCustomerPool requires at least one app client');\n    }\n\n    if ((props.customEmailSenderLambda === undefined) !== (props.customSenderKmsKey === undefined)) {\n      throw new Error(\n        'CognitoCustomerPool: customEmailSenderLambda and customSenderKmsKey must be provided together — '\n        + 'a custom email sender requires a KMS key for Cognito to encrypt codes to, and the key is unused without the Lambda.',\n      );\n    }\n\n    if (props.emailOtpMfa && !props.customEmailSenderLambda) {\n      throw new Error(\n        'CognitoCustomerPool: emailOtpMfa requires customEmailSenderLambda (and customSenderKmsKey) — '\n        + 'EMAIL_OTP codes are delivered by the custom email sender, so email MFA cannot be enabled without it.',\n      );\n    }\n\n    if (props.emailOtpMfa && !props.emailConfiguration) {\n      throw new Error(\n        'CognitoCustomerPool: emailOtpMfa requires emailConfiguration — '\n        + 'Cognito refuses to enable EMAIL_OTP MFA unless the pool carries a DEVELOPER SES '\n        + 'EmailConfiguration on a verified same-account identity. This precondition is checked '\n        + 'before any email is routed, so the custom email sender does not satisfy it.',\n      );\n    }\n\n    if (props.passwordlessEmailOtp && props.emailOtpMfa) {\n      throw new Error(\n        'CognitoCustomerPool: passwordlessEmailOtp and emailOtpMfa are mutually exclusive — '\n        + 'passwordless uses EMAIL_OTP as a FIRST auth factor (MFA off), while emailOtpMfa uses it '\n        + 'as a SECOND factor (MFA on). Choose one.',\n      );\n    }\n\n    if (props.passwordlessEmailOtp && (!props.customEmailSenderLambda || !props.emailConfiguration)) {\n      throw new Error(\n        'CognitoCustomerPool: passwordlessEmailOtp requires customEmailSenderLambda, customSenderKmsKey '\n        + 'and emailConfiguration — the first-factor EMAIL_OTP code is delivered by the custom email '\n        + 'sender, and Cognito requires the same DEVELOPER SES EmailConfiguration enablement precondition.',\n      );\n    }\n\n    // With emailOtpMfa, EMAIL_OTP is the sole factor and is applied via an L1\n    // override below; do NOT pass mfaSecondFactor.email to the L2 (its validateEmailMfa\n    // demands a `email` UserPoolEmail be set, which we supply separately via\n    // emailConfiguration — see the `email` prop below).\n    const l2MfaSecondFactor = props.emailOtpMfa\n      ? { otp: false, sms: false }\n      : (props.mfaSecondFactor ?? { otp: true, sms: false });\n\n    const accountRecovery = props.emailOtpMfa\n    // Cognito rejects EmailMfaConfiguration unless AccountRecoverySetting has at\n    // least one mechanism other than verified_email (recovering email-based MFA via\n    // email is circular). AccountRecovery.NONE maps to the admin_only mechanism, which\n    // satisfies the constraint without introducing an SMS/phone factor into this\n    // passwordless-email design. Otherwise keep the email-only default.\n      ? cognito.AccountRecovery.NONE\n      : cognito.AccountRecovery.EMAIL_ONLY;\n\n    // Passwordless uses EMAIL_OTP as a FIRST auth factor, which Cognito forbids while\n    // MFA is ON (\"Only PASSWORD and WEB_AUTHN can be enabled as an auth factor if MFA\n    // is enabled\"). So passwordless forces MFA OFF. NB: the OFF->ON transition is\n    // irreversible via the API — a pool created passwordless cannot later gain MFA in place.\n    const mfaConfig = props.passwordlessEmailOtp\n      ? cognito.Mfa.OFF\n      : (props.mfa ?? cognito.Mfa.REQUIRED);\n\n    this.userPool = new cognito.UserPool(this, 'UserPool', {\n      userPoolName: props.userPoolName,\n      selfSignUpEnabled: props.selfSignUpEnabled ?? false,\n      signInAliases: { email: true },\n      signInCaseSensitive: false,\n      mfa: mfaConfig,\n      mfaSecondFactor: l2MfaSecondFactor,\n      passwordPolicy: props.passwordPolicy ?? {\n        minLength: 12,\n        requireLowercase: true,\n        requireUppercase: true,\n        requireDigits: true,\n        requireSymbols: true,\n      },\n      advancedSecurityMode: props.advancedSecurityMode ?? cognito.AdvancedSecurityMode.OFF,\n      standardAttributes: props.standardAttributes,\n      customAttributes: props.customAttributes,\n      autoVerify: { email: true },\n      accountRecovery,\n      // Custom Email Sender: when provided, Cognito routes every customer email\n      // through this Lambda and encrypts codes to customSenderKmsKey. Both must be\n      // set on the pool at construction — the KMS key is not settable via addTrigger.\n      customSenderKmsKey: props.customSenderKmsKey,\n      lambdaTriggers: props.customEmailSenderLambda\n        ? { customEmailSender: props.customEmailSenderLambda }\n        : undefined,\n      removalPolicy: props.removalPolicy ?? core.RemovalPolicy.RETAIN,\n    });\n\n    // L1 escape hatch: enable EMAIL_OTP as the only MFA factor. The L2 cannot express\n    // \"email MFA delivered solely by a custom sender\" (see emailOtpMfa docs), so set\n    // EnabledMfas directly on the underlying CfnUserPool. The custom email sender\n    // delivers the code, but Cognito still requires a DEVELOPER SES EmailConfiguration\n    // on a verified same-account identity as an ENABLEMENT precondition (below).\n    if (props.emailConfiguration) {\n      // Set EmailConfiguration via L1 with the caller's exact verified same-account\n      // identity ARN — accepting either a domain or an email-address identity without\n      // CDK re-deriving the ARN from the From address. This satisfies Cognito's\n      // EMAIL_OTP enablement precondition; the custom email sender still overrides\n      // actual delivery, so this identity is never sent through.\n      const cfnPool = this.userPool.node.defaultChild as cognito.CfnUserPool;\n      cfnPool.emailConfiguration = {\n        emailSendingAccount: 'DEVELOPER',\n        sourceArn: props.emailConfiguration.sesVerifiedDomainArn,\n        from: props.emailConfiguration.fromName\n          ? `${props.emailConfiguration.fromName} <${props.emailConfiguration.fromEmail}>`\n          : props.emailConfiguration.fromEmail,\n      };\n    }\n\n    if (props.emailOtpMfa) {\n      const cfnPool = this.userPool.node.defaultChild as cognito.CfnUserPool;\n      cfnPool.enabledMfas = ['EMAIL_OTP'];\n    }\n\n    if (props.passwordlessEmailOtp) {\n      // Choice-based sign-in: EMAIL_OTP as a first auth factor. PASSWORD is MANDATORY\n      // in AllowedFirstAuthFactors (Cognito rejects a list without it), so it stays —\n      // but the app client below drops the password (userSrp) flow and the consumer's\n      // UI never offers it, so the password path is unreachable through this client.\n      const cfnPool = this.userPool.node.defaultChild as cognito.CfnUserPool;\n      cfnPool.policies = {\n        ...(cfnPool.policies as cognito.CfnUserPool.PoliciesProperty | undefined),\n        signInPolicy: { allowedFirstAuthFactors: ['PASSWORD', 'EMAIL_OTP'] },\n      };\n    }\n\n    const preTokenLambda = props.preTokenGenerationLambda ?? new lambda.Function(this, 'PreTokenLambda', {\n      runtime: lambda.Runtime.PYTHON_3_12,\n      handler: 'index.handler',\n      code: lambda.Code.fromAsset(path.join(__dirname, '../lambda/pre-token')),\n      timeout: core.Duration.seconds(5),\n    });\n    this.userPool.addTrigger(cognito.UserPoolOperation.PRE_TOKEN_GENERATION_CONFIG, preTokenLambda, cognito.LambdaVersion.V2_0);\n\n    if (props.groups) {\n      for (const group of props.groups) {\n        new cognito.CfnUserPoolGroup(this, `Group${group}`, {\n          userPoolId: this.userPool.userPoolId,\n          groupName: group,\n        });\n      }\n    }\n\n    // Optional advanced-security risk configuration (L1).\n    if (props.accountTakeoverRiskConfiguration || props.compromisedCredentialsRiskConfiguration) {\n      new cognito.CfnUserPoolRiskConfigurationAttachment(this, 'RiskConfig', {\n        userPoolId: this.userPool.userPoolId,\n        clientId: 'ALL',\n        accountTakeoverRiskConfiguration: props.accountTakeoverRiskConfiguration,\n        compromisedCredentialsRiskConfiguration: props.compromisedCredentialsRiskConfiguration,\n      });\n    }\n\n    this.userPoolClients = {};\n    for (const spec of props.appClients) {\n      const client = new cognito.UserPoolClient(this, `Client${spec.key}`, {\n        userPool: this.userPool,\n        generateSecret: spec.generateSecret ?? false,\n        authFlows: props.passwordlessEmailOtp\n          ? {\n            // Passwordless: enable choice-based ALLOW_USER_AUTH and DROP userSrp so the\n            // password challenge cannot be initiated through this client — even by a\n            // direct API call. PASSWORD stays a pool factor (Cognito's rule) but is\n            // unreachable via the storefront client.\n            user: true,\n            custom: props.enableCustomAuthFlow ?? false,\n          }\n          : {\n            userSrp: true,\n            custom: props.enableCustomAuthFlow ?? false,\n            // userPassword / adminUserPassword intentionally omitted (disabled).\n          },\n        oAuth: {\n          flows: { authorizationCodeGrant: true },\n          scopes: [cognito.OAuthScope.OPENID, cognito.OAuthScope.EMAIL, cognito.OAuthScope.PROFILE],\n          callbackUrls: spec.callbackUrls,\n          logoutUrls: spec.logoutUrls,\n        },\n        supportedIdentityProviders: spec.supportedIdentityProviders ?? [cognito.UserPoolClientIdentityProvider.COGNITO],\n        preventUserExistenceErrors: true,\n        enableTokenRevocation: true,\n        accessTokenValidity: props.accessTokenValidity ?? core.Duration.hours(1),\n        idTokenValidity: props.idTokenValidity ?? core.Duration.hours(1),\n        refreshTokenValidity: props.refreshTokenValidity ?? core.Duration.days(30),\n      });\n      this.userPoolClients[spec.key] = client;\n    }\n    this.userPoolClient = this.userPoolClients[props.appClients[0].key];\n\n    this.userPoolDomain = this.userPool.addDomain('CognitoDomain', {\n      cognitoDomain: { domainPrefix: props.cognitoDomainPrefix },\n    });\n    this.cognitoDomainUrl = `${props.cognitoDomainPrefix}.auth.${core.Stack.of(this).region}.amazoncognito.com`;\n\n    if (props.identityPool) {\n      const idp = props.identityPool;\n      this.identityPool = new cognito.CfnIdentityPool(this, 'IdentityPool', {\n        allowUnauthenticatedIdentities: idp.allowUnauthenticatedIdentities ?? false,\n        cognitoIdentityProviders: props.appClients.map(spec => ({\n          clientId: this.userPoolClients[spec.key].userPoolClientId,\n          providerName: this.userPool.userPoolProviderName,\n          serverSideTokenCheck: true,\n        })),\n      });\n\n      this.authenticatedRole = new iam.Role(this, 'AuthenticatedRole', {\n        assumedBy: new iam.FederatedPrincipal(\n          'cognito-identity.amazonaws.com',\n          {\n            'StringEquals': { 'cognito-identity.amazonaws.com:aud': this.identityPool.ref },\n            'ForAnyValue:StringLike': { 'cognito-identity.amazonaws.com:amr': 'authenticated' },\n          },\n          'sts:AssumeRoleWithWebIdentity',\n        ),\n        managedPolicies: idp.authenticatedRoleManagedPolicies,\n      });\n\n      new cognito.CfnIdentityPoolRoleAttachment(this, 'IdentityPoolRoles', {\n        identityPoolId: this.identityPool.ref,\n        roles: { authenticated: this.authenticatedRole.roleArn },\n      });\n\n      // ABAC: map claims to principal tags on the user-pool provider.\n      if (idp.principalTags && Object.keys(idp.principalTags).length > 0) {\n        new cognito.CfnIdentityPoolPrincipalTag(this, 'PrincipalTags', {\n          identityPoolId: this.identityPool.ref,\n          identityProviderName: this.userPool.userPoolProviderName,\n          useDefaults: false,\n          principalTags: idp.principalTags,\n        });\n      }\n    }\n  }\n}\n"]}

package/package.json

@@ -59,7 +59,7 @@
   },
   "main": "lib/index.js",
   "license": "Apache-2.0",
-  "version": "0.0.42",
+  "version": "0.0.44",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [