@aws-amplify/backend-notifications 0.0.0-test-20260708085627

package/lib/construct.js

@@ -0,0 +1,824 @@
+import * as path from 'path';
+import { createHash } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { Arn, ArnFormat, CfnOutput, CustomResource, Duration, Stack, } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import { Provider } from 'aws-cdk-lib/custom-resources';
+import { CfnDomain, CfnIntegration, CfnObjectType, } from 'aws-cdk-lib/aws-customerprofiles';
+import { CfnInstance, CfnIntegrationAssociation, } from 'aws-cdk-lib/aws-connect';
+import { CfnKnowledgeBase } from 'aws-cdk-lib/aws-wisdom';
+import { CfnAPNSChannel, CfnAPNSSandboxChannel, CfnApp, CfnGCMChannel, } from 'aws-cdk-lib/aws-pinpoint';
+import * as apigwv2 from 'aws-cdk-lib/aws-apigatewayv2';
+import { HttpIamAuthorizer, HttpJwtAuthorizer, } from 'aws-cdk-lib/aws-apigatewayv2-authorizers';
+import { HttpLambdaIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
+import { CONNECT_CAMPAIGNS_SERVICE_NAME, CONNECT_INVOKE_SERVICE_PRINCIPALS, DEFAULT_EXPIRATION_DAYS, ENV_DOMAIN_NAME, ENV_EUM_APPLICATION_ID, } from './constants.js';
+import { AMPLIFY_DEVICE_FIELDS, AMPLIFY_DEVICE_KEYS, AMPLIFY_GUEST_PROFILE_FIELDS, AMPLIFY_GUEST_PROFILE_KEYS, AMPLIFY_PROFILE_FIELDS, AMPLIFY_PROFILE_KEYS, OBJECT_TYPE_NAMES, } from './object_types.js';
+/**
+ * The pre-bundled identify-user Lambda asset ships alongside the compiled
+ * construct at `<packageRoot>/lib/handler-asset` (produced by the package's
+ * `post:compile` esbuild step). Resolving relative to the package root — rather
+ * than to this module — means the path is correct whether the code runs from
+ * the compiled `lib/` output or from `src/` under `tsx` (as the unit tests do).
+ */
+const packageRoot = fileURLToPath(new URL('..', import.meta.url));
+const defaultLambdaCodePath = path.join(packageRoot, 'lib', 'handler-asset');
+const defaultPushLambdaCodePath = path.join(packageRoot, 'lib', 'push-handler-asset');
+const defaultCampaignAssociationLambdaCodePath = path.join(packageRoot, 'lib', 'campaign-association-asset');
+/**
+ * Amazon Connect Customer Profiles backend for the identifyUser contract,
+ * packaged as an AWS CDK construct. Provisions:
+ *   - AmplifyProfile object type: searchable `cognitoUserKey` (PROFILE + UNIQUE)
+ *     identity key + person / targeting attribute schema.
+ *   - AmplifyDevice object type: PROFILE-resolution key = `cognitoUserKey`,
+ *     UNIQUE object key = stable `deviceId`; device fields stored raw.
+ *   - identify-user Lambda with least-privilege profile:* on this domain only.
+ *   - HTTP API + JWT authorizer bound to the supplied issuer / audience.
+ *   - push-delivery Lambda (Connect Journey Custom-action target) + a minimal
+ *     AWS End User Messaging (Pinpoint) application for `SendMessages`.
+ *
+ * It operates in one of two modes, chosen by whether `domainName` is provided:
+ *
+ *   - CREATE-FROM-SCRATCH (default, `domainName` omitted): the construct also
+ *     provisions a brand-new Amazon Connect instance (`AWS::Connect::Instance`,
+ *     CONNECT_MANAGED, inbound/outbound enabled) AND a brand-new Customer
+ *     Profiles domain (`AWS::CustomerProfiles::Domain`) with generated, stable
+ *     names, then registers the object types INTO that new domain. The object
+ *     types depend on the created domain so they provision after it and are torn
+ *     down before it. A caller needs zero pre-existing Connect setup.
+ *   - ATTACH (`domainName` provided): the construct registers the two object
+ *     types INTO the existing `domainName` (additive) — such as the domain
+ *     Amazon Connect auto-creates when Customer Profiles is enabled on an
+ *     instance — WITHOUT creating an instance or a domain, and without touching
+ *     the domain's other integrations (CTR, Outbound Campaigns) or its Identity
+ *     Resolution setting.
+ *
+ * In either mode, identify works against the domain standalone. Outbound
+ * Campaigns association — so journeys can target these profiles — is AUTOMATIC
+ * in create-from-scratch mode (a Lambda-backed custom resource associates the
+ * new domain with the new instance's Outbound Campaigns v2 at deploy time). In
+ * attach mode, associating the pre-existing domain is the user's responsibility
+ * and is left untouched.
+ *
+ * This construct is framework-agnostic (aws-cdk-lib + constructs only). The
+ * `defineNotifications` factory wraps it for Amplify Gen2 backends, wiring the
+ * JWT authorizer to the app's Cognito user pool and surfacing the endpoint via
+ * backend outputs.
+ */
+export class AmplifyNotifications extends Construct {
+    /** CDK resources for lower-level access. */
+    resources;
+    /** The stack this construct belongs to. */
+    stack;
+    /** Base invoke URL. Clients call `POST {apiEndpoint}/identify-user`. */
+    apiEndpoint;
+    /** The route path appended to {@link apiEndpoint}. */
+    identifyUserPath = '/identify-user';
+    /**
+     * The GUEST route path appended to {@link apiEndpoint}.
+     * IAM/SigV4-authorized; unauthenticated Identity Pool callers sign requests to
+     * `POST {apiEndpoint}/identify-user-guest`.
+     */
+    guestIdentifyUserPath = '/identify-user-guest';
+    /**
+     * The `execute-api:Invoke` ARN of the GUEST route, to
+     * grant to the app's Cognito Identity Pool UNAUTHENTICATED role so guests can
+     * call the route. Scoped to POST on the guest path of this API's default
+     * stage.
+     */
+    guestRouteInvokeArn;
+    /** The Customer Profiles domain name the object types are registered into. */
+    domainName;
+    /**
+     * `true` when this construct created the Customer Profiles domain + Connect
+     * instance (create-from-scratch mode); `false` when it attached to an existing
+     * domain named by `domainName`.
+     */
+    createsResources;
+    /**
+     * Id of the Amazon Connect instance created in create-from-scratch mode.
+     * `undefined` in attach mode.
+     */
+    connectInstanceId;
+    /**
+     * ARN of the Amazon Connect instance created in create-from-scratch mode.
+     * `undefined` in attach mode.
+     */
+    connectInstanceArn;
+    /**
+     * ARN of the push-delivery Lambda, to wire as a Connect Journey Custom-action
+     * (Invoke Lambda) target.
+     */
+    pushFunctionArn;
+    /**
+     * The AWS End User Messaging / Pinpoint application id this construct created
+     * and the push Lambda calls `SendMessages` against.
+     */
+    eumApplicationId;
+    /**
+     * Registers the AmplifyProfile / AmplifyDevice object types into the Customer
+     * Profiles domain (created here in create-from-scratch mode, or the existing
+     * `domainName` in attach mode), the identify-user Lambda + JWT-authorized HTTP
+     * API, and the push-delivery Lambda + AWS End User Messaging application for
+     * this notifications backend.
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        const stack = Stack.of(this);
+        this.stack = stack;
+        const expirationDays = props.expirationDays ?? DEFAULT_EXPIRATION_DAYS;
+        // ---- Mode selection: create-from-scratch (default) vs attach -----------
+        // If a `domainName` is supplied, ATTACH the object types to that existing
+        // domain (create nothing). Otherwise (the zero-config default) CREATE a
+        // brand-new Connect instance + Customer Profiles domain with generated,
+        // stable names and register the object types into the new domain.
+        const createFromScratch = !props.domainName;
+        this.createsResources = createFromScratch;
+        let domainName;
+        let profilesDomain;
+        let connectInstance;
+        if (createFromScratch) {
+            // Deterministic-yet-unique base name derived from the construct's scope so
+            // it is STABLE across deploy/delete (same tree → same name) and unique per
+            // app / environment (the root stack name embeds the Amplify app + branch).
+            const baseName = this.generateResourceName();
+            domainName = baseName;
+            connectInstance = new CfnInstance(this, 'ConnectInstance', {
+                // Minimal telephony surface: Connect requires at least one of
+                // inbound/outbound; enable both so the instance is usable for outbound
+                // journeys later. Directory is Connect-managed (no external identity).
+                //
+                // highVolumeOutBound enables the instance's Outbound Campaigns feature.
+                // This is what makes Amazon Connect attach the
+                // `HighVolumeOutboundCommunicationAccess` inline policy to the instance's
+                // OWN service-linked role — the policy granting the `connect-campaigns:*`
+                // (CreateCampaign / ListCampaigns / ...) actions the Connect console
+                // drives Journey + campaign authoring through. Onboarding to Outbound
+                // Campaigns v2 (the campaign-association custom resource) does NOT set
+                // it, so without this the console's Journey / segment builder fails with
+                // connect-campaigns AccessDenied on the instance SLR.
+                attributes: {
+                    inboundCalls: true,
+                    outboundCalls: true,
+                    highVolumeOutBound: true,
+                },
+                identityManagementType: 'CONNECT_MANAGED',
+                instanceAlias: this.sanitizeInstanceAlias(props.instanceAlias ?? baseName),
+            });
+            profilesDomain = new CfnDomain(this, 'ProfilesDomain', {
+                domainName,
+                defaultExpirationDays: expirationDays,
+            });
+            this.connectInstanceId = connectInstance.attrId;
+            this.connectInstanceArn = connectInstance.attrArn;
+            // Instance-level Customer Profiles feature binding: registers the created
+            // domain as the instance's CTR (contact-record) profiles store — the
+            // "Customer Profiles enabled" integration the Connect console and Journey
+            // segment builder require, distinct from the Outbound Campaigns
+            // integration the association custom resource wires below. PutIntegration
+            // auto-resolves the Connect service-linked role for a connect-instance
+            // URI; that SLR can only reach the domain because it is named
+            // `amazon-connect-*` (see generateResourceName).
+            const ctrIntegration = new CfnIntegration(this, 'ConnectProfilesIntegration', {
+                domainName,
+                uri: connectInstance.attrArn,
+                objectTypeName: 'CTR',
+            });
+            ctrIntegration.addDependency(connectInstance);
+            ctrIntegration.addDependency(profilesDomain);
+            // Message-templates knowledge base + its instance association. Both the
+            // Connect console's message-template authoring UI and the push-delivery
+            // Lambda's runtime discovery (ListIntegrationAssociations filtered to
+            // Q_MESSAGE_TEMPLATES → the KB it renders templates from) require a
+            // MESSAGE_TEMPLATES knowledge base linked to the instance. We provision
+            // the empty KB + the Q_MESSAGE_TEMPLATES association only; the templates
+            // themselves are the marketer's job (a template's name must match the
+            // journey Custom-action id, e.g. "Push Notification"). A MESSAGE_TEMPLATES
+            // KB needs no Q assistant. The name is derived from the same deterministic
+            // base as the instance/domain so redeploys stay stable and avoid the
+            // CreateKnowledgeBase ConflictException on duplicate names.
+            const templatesKb = new CfnKnowledgeBase(this, 'MessageTemplatesKb', {
+                name: `${baseName}-message-templates`,
+                knowledgeBaseType: 'MESSAGE_TEMPLATES',
+            });
+            const templatesAssociation = new CfnIntegrationAssociation(this, 'MessageTemplatesAssociation', {
+                instanceId: connectInstance.attrArn,
+                integrationType: 'Q_MESSAGE_TEMPLATES',
+                integrationArn: templatesKb.attrKnowledgeBaseArn,
+            });
+            templatesAssociation.addDependency(connectInstance);
+            templatesAssociation.addDependency(templatesKb);
+        }
+        else {
+            domainName = props.domainName;
+        }
+        this.domainName = domainName;
+        // ---- Object types ------------------------------------------------------
+        // Registered INTO `domainName`. In attach mode this is purely additive to a
+        // pre-existing (e.g. Connect-managed) domain. In create mode the object
+        // types depend on the domain created above, so CFN provisions the domain
+        // first and — on teardown — removes the object types before the domain (a
+        // clean, in-construct dependency; no cross-stack ordering hack needed).
+        const profileType = new CfnObjectType(this, 'AmplifyProfileType', {
+            domainName,
+            objectTypeName: OBJECT_TYPE_NAMES.profile,
+            description: 'Amplify identifyUser person profile (find-or-create by verified Cognito sub)',
+            allowProfileCreation: true,
+            fields: AMPLIFY_PROFILE_FIELDS,
+            keys: AMPLIFY_PROFILE_KEYS,
+            expirationDays,
+        });
+        const deviceType = new CfnObjectType(this, 'AmplifyDeviceType', {
+            domainName,
+            objectTypeName: OBJECT_TYPE_NAMES.device,
+            description: 'Amplify identifyUser device (unique per stable deviceId; token is a mutable field; resolves to profile by cognitoUserKey)',
+            allowProfileCreation: true,
+            fields: AMPLIFY_DEVICE_FIELDS,
+            keys: AMPLIFY_DEVICE_KEYS,
+            expirationDays,
+        });
+        // A distinct object type for GUEST profiles. Customer
+        // Profiles permits exactly one UNIQUE key per object type and PutProfileObject
+        // requires the ingested object to carry it; the authed AmplifyProfile reserves
+        // its UNIQUE key for cognitoSub, so guest profiles (keyed on the Identity Pool
+        // cognitoIdentityId) get their own type with cognitoIdentityKey as UNIQUE.
+        const guestProfileType = new CfnObjectType(this, 'AmplifyGuestProfileType', {
+            domainName,
+            objectTypeName: OBJECT_TYPE_NAMES.guestProfile,
+            description: 'Amplify identifyUser GUEST person profile (find-or-create by verified Cognito Identity Pool identityId)',
+            allowProfileCreation: true,
+            fields: AMPLIFY_GUEST_PROFILE_FIELDS,
+            keys: AMPLIFY_GUEST_PROFILE_KEYS,
+            expirationDays,
+        });
+        if (profilesDomain) {
+            profileType.addDependency(profilesDomain);
+            deviceType.addDependency(profilesDomain);
+            guestProfileType.addDependency(profilesDomain);
+        }
+        // ---- Outbound Campaigns association (create-from-scratch ONLY) ----------
+        // When this construct created the instance + domain, a Lambda-backed custom
+        // resource associates the new domain with the instance's Outbound Campaigns
+        // v2 at deploy time — so Connect Journeys can target the domain's profiles
+        // with NO manual console step. In attach mode the existing domain's
+        // association is the user's responsibility, so this resource is NOT added.
+        if (createFromScratch && connectInstance && profilesDomain) {
+            this.addCampaignAssociation(connectInstance, profilesDomain, domainName, props.campaignAssociationLambdaCodePath ??
+                defaultCampaignAssociationLambdaCodePath);
+        }
+        // ---- Lambda handler ----------------------------------------------------
+        // Pre-bundled at build time (esbuild) into a self-contained asset, so the
+        // construct works regardless of the consuming project's root (Amplify's
+        // NodejsFunction guardrail forbids an entry outside the app root).
+        const codePath = props.lambdaCodePath ?? defaultLambdaCodePath;
+        const fn = new lambda.Function(this, 'IdentifyUserFn', {
+            code: lambda.Code.fromAsset(codePath),
+            handler: 'index.handler',
+            runtime: lambda.Runtime.NODEJS_20_X,
+            timeout: Duration.seconds(15),
+            memorySize: 256,
+            environment: {
+                [ENV_DOMAIN_NAME]: domainName,
+            },
+        });
+        // ---- Least-privilege IAM ----------------------------------------------
+        const domainArn = Arn.format({
+            service: 'profile',
+            resource: 'domains',
+            resourceName: domainName,
+            arnFormat: ArnFormat.SLASH_RESOURCE_NAME,
+        }, stack);
+        const objectTypesArn = Arn.format({
+            service: 'profile',
+            resource: 'domains',
+            resourceName: `${domainName}/object-types/*`,
+            arnFormat: ArnFormat.SLASH_RESOURCE_NAME,
+        }, stack);
+        fn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: [
+                // PutProfileObject find-or-create (AmplifyProfile) + read-back.
+                'profile:PutProfileObject',
+                'profile:SearchProfiles',
+                // Read back the existing device object to preserve immutable createdAt.
+                'profile:ListProfileObjects',
+                // Set targeting / person attributes on the resolved profile.
+                'profile:UpdateProfile',
+            ],
+            resources: [domainArn, objectTypesArn],
+        }));
+        // Merge-on-sign-in folds a prior guest profile
+        // (+ its device objects) into the authed profile via MergeProfiles.
+        // NOTE: the Service Authorization Reference lists MergeProfiles under the
+        // `domains` resource type, but the service ACTUALLY authorizes it against
+        // an undocumented, differently-shaped resource ARN (note the leading slash
+        // and the /profiles/objects/merge suffix):
+        //   arn:<partition>:profile:<region>:<account>:/domains/<domain>/profiles/objects/merge
+        // Granting the documented domain ARN is NOT sufficient. This dedicated
+        // statement targets the enforced resource.
+        const mergeProfilesArn = `arn:${stack.partition}:profile:${stack.region}:${stack.account}:/domains/${domainName}/profiles/objects/merge`;
+        fn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: ['profile:MergeProfiles'],
+            resources: [mergeProfilesArn],
+        }));
+        // ---- HTTP API + JWT authorizer ----------------------------------------
+        const authorizer = new HttpJwtAuthorizer('JwtAuthorizer', props.jwtIssuer, {
+            jwtAudience: props.jwtAudience,
+            identitySource: ['$request.header.Authorization'],
+        });
+        const httpApi = new apigwv2.HttpApi(this, 'IdentifyUserApi', {
+            apiName: 'identify-user-api',
+            createDefaultStage: true,
+        });
+        httpApi.addRoutes({
+            path: this.identifyUserPath,
+            methods: [apigwv2.HttpMethod.POST],
+            integration: new HttpLambdaIntegration('IdentifyUserIntegration', fn),
+            authorizer,
+        });
+        // ---- Guest (unauthenticated) route ------------------------------------
+        // A second route to the SAME identify Lambda, but
+        // authorized with IAM/SigV4 instead of a JWT — so an UNAUTHENTICATED Cognito
+        // Identity Pool caller (guest credentials) can register a device / seed a
+        // profile BEFORE login (the pre-login push-token case).
+        //
+        // The integration MUST use payload format 1.0: HTTP API payload format 2.0
+        // has NO `requestContext.identity` block, so the verified Cognito
+        // `cognitoIdentityId` (+ `cognitoAuthenticationType`) the Lambda keys the
+        // guest profile on is only present under format 1.0. The Lambda derives the
+        // guest identity SOLELY from that authorizer-verified field.
+        const iamAuthorizer = new HttpIamAuthorizer();
+        httpApi.addRoutes({
+            path: this.guestIdentifyUserPath,
+            methods: [apigwv2.HttpMethod.POST],
+            integration: new HttpLambdaIntegration('GuestIdentifyIntegration', fn, {
+                payloadFormatVersion: apigwv2.PayloadFormatVersion.VERSION_1_0,
+            }),
+            authorizer: iamAuthorizer,
+        });
+        // `execute-api:Invoke` ARN for the guest route — the app grants this to its
+        // Identity Pool UNAUTHENTICATED role so guests can call the route. Scoped as
+        // tightly as execute-api allows: `$default/POST/identify-user-guest` pins the
+        // grant to the POST method on the guest path of the API's single default
+        // stage, so the unauth role can invoke NEITHER other methods, NOR other
+        // stages, NOR the authed `/identify-user` route. (HTTP APIs auto-create the
+        // `$default` stage; this construct never adds another.)
+        this.guestRouteInvokeArn = Arn.format({
+            service: 'execute-api',
+            resource: httpApi.apiId,
+            resourceName: `$default/POST${this.guestIdentifyUserPath}`,
+            arnFormat: ArnFormat.SLASH_RESOURCE_NAME,
+        }, stack);
+        this.apiEndpoint = httpApi.apiEndpoint;
+        // Scoped to the stack (not `this`) so the output keeps a stable, readable
+        // logical id (`IdentifyUserApiEndpoint`) that a human can find in the
+        // CloudFormation console. The construct is provisioned once per stack (the
+        // Gen2 factory places it in a dedicated nested stack), so there is no
+        // collision risk from the verbatim id.
+        new CfnOutput(stack, 'IdentifyUserApiEndpoint', {
+            value: httpApi.apiEndpoint,
+            description: 'POST {value}/identify-user',
+        });
+        // Surface the guest route's invoke ARN so a human /
+        // the app can grant it to the Identity Pool unauthenticated role.
+        new CfnOutput(stack, 'GuestIdentifyRouteInvokeArn', {
+            value: this.guestRouteInvokeArn,
+            description: 'Grant execute-api:Invoke on this ARN to the Cognito Identity Pool unauthenticated role',
+        });
+        // ---- Push-delivery path -----------------------------------------------
+        // Amazon Connect has no native mobile-push channel, so a Lambda bridges the
+        // gap: Connect invokes it via a Journey Custom-action to deliver push
+        // through AWS End User Messaging (Pinpoint SendMessages). A minimal Pinpoint
+        // application is always created so SendMessages has a valid ApplicationId.
+        // The APNs / GCM channels on it are configured only when the caller supplies
+        // credentials (see `apnsChannel` / `fcmChannel`); otherwise the application
+        // is created with no channel enabled (delivery will 404 until configured).
+        const pushApplication = new CfnApp(this, 'PushApp', {
+            name: `${domainName}-push`,
+        });
+        const eumApplicationId = pushApplication.ref;
+        this.eumApplicationId = eumApplicationId;
+        // ---- Optional push channels (secret-driven) ---------------------------
+        // The Amplify Gen2 factory resolves the APNs `.p8` key / FCM service-account
+        // JSON from Amplify `secret()`s to deploy-time CFN tokens and passes them as
+        // plain strings. Channel credentials flow through CloudFormation the same way
+        // Amplify's own external-auth-provider secrets do (defineAuth) — via the
+        // secret custom resource's token, never as literal template plain text. The
+        // channels attach to THIS construct's own EUM app, so they are provisioned
+        // after it and torn down with the stack. The `applicationId` prop resolves to
+        // a `Ref` on the EUM app, so CloudFormation infers the create/delete ordering
+        // — no explicit `addDependency` needed.
+        const { apnsChannel: apnsConfig, fcmChannel: fcmConfig } = props;
+        let apnsChannel;
+        if (apnsConfig) {
+            // Token (`.p8`) authentication: the CFN `DefaultAuthenticationMethod`
+            // property accepts `TOKEN` (signing-key auth) or `CERTIFICATE`; token auth
+            // uses the `.p8` signing key. Sandbox selects the development APNs endpoint
+            // used by development-signed builds.
+            const apnsProps = {
+                applicationId: eumApplicationId,
+                enabled: true,
+                defaultAuthenticationMethod: 'TOKEN',
+                tokenKey: apnsConfig.tokenKey,
+                tokenKeyId: apnsConfig.keyId,
+                teamId: apnsConfig.teamId,
+                bundleId: apnsConfig.bundleId,
+            };
+            apnsChannel = apnsConfig.sandbox
+                ? new CfnAPNSSandboxChannel(this, 'ApnsSandboxChannel', apnsProps)
+                : new CfnAPNSChannel(this, 'ApnsChannel', apnsProps);
+        }
+        let gcmChannel;
+        if (fcmConfig) {
+            // FCM HTTP v1: `TOKEN` auth with a service-account JSON credential. Google
+            // deprecated the legacy server-key (`ApiKey` / `KEY`) API, so only the v1
+            // `ServiceJson` (FCM v1) path is used.
+            gcmChannel = new CfnGCMChannel(this, 'GcmChannel', {
+                applicationId: eumApplicationId,
+                enabled: true,
+                defaultAuthenticationMethod: 'TOKEN',
+                serviceJson: fcmConfig.serviceJson,
+            });
+        }
+        const pushCodePath = props.pushLambdaCodePath ?? defaultPushLambdaCodePath;
+        const pushFn = new lambda.Function(this, 'PushHandlerFn', {
+            code: lambda.Code.fromAsset(pushCodePath),
+            handler: 'index.handler',
+            runtime: lambda.Runtime.NODEJS_20_X,
+            timeout: Duration.seconds(30),
+            memorySize: 256,
+            environment: {
+                [ENV_DOMAIN_NAME]: domainName,
+                [ENV_EUM_APPLICATION_ID]: eumApplicationId,
+            },
+        });
+        // Least-privilege: read + delete device objects on THIS domain only, and
+        // SendMessages scoped to THIS EUM application.
+        pushFn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: [
+                // Resolve a profile's registered devices (tokens + channels).
+                'profile:ListProfileObjects',
+                // Stale-token cleanup: delete a device whose token is dead.
+                'profile:DeleteProfileObject',
+            ],
+            resources: [domainArn, objectTypesArn],
+        }));
+        const appMessagesArn = Arn.format({
+            service: 'mobiletargeting',
+            resource: 'apps',
+            resourceName: `${eumApplicationId}/messages`,
+            arnFormat: ArnFormat.SLASH_RESOURCE_NAME,
+        }, stack);
+        pushFn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: ['mobiletargeting:SendMessages'],
+            resources: [appMessagesArn],
+        }));
+        // ---- Runtime message-template resolution (Q in Connect) ---------------
+        // The push Lambda resolves per-profile copy from a Q in Connect (Wisdom)
+        // PUSH message template at runtime: it discovers the knowledge base from the
+        // journey's campaign (DescribeCampaign -> connectInstanceId ->
+        // ListIntegrationAssociations) and renders the template whose name matches
+        // the Custom-action ActionId. Least-privilege, scoped to this account /
+        // region. IAM prefixes confirmed empirically: campaign actions use
+        // `connect-campaigns`, integration listing uses `connect`, and Q in Connect
+        // message-template actions use the `wisdom` prefix (Q in Connect is the
+        // rebrand of Amazon Connect Wisdom; the SDK client is `@aws-sdk/client-qconnect`
+        // but IAM/ARNs remain `wisdom`).
+        pushFn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: ['connect-campaigns:DescribeCampaign'],
+            resources: [
+                Arn.format({
+                    service: 'connect-campaigns',
+                    resource: 'campaign',
+                    resourceName: '*',
+                    arnFormat: ArnFormat.SLASH_RESOURCE_NAME,
+                }, stack),
+            ],
+        }));
+        pushFn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: ['connect:ListIntegrationAssociations'],
+            resources: [
+                Arn.format({
+                    service: 'connect',
+                    resource: 'instance',
+                    resourceName: '*',
+                    arnFormat: ArnFormat.SLASH_RESOURCE_NAME,
+                }, stack),
+            ],
+        }));
+        pushFn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: [
+                'wisdom:ListMessageTemplates',
+                'wisdom:GetMessageTemplate',
+                'wisdom:RenderMessageTemplate',
+            ],
+            resources: [
+                Arn.format({
+                    service: 'wisdom',
+                    resource: 'knowledge-base',
+                    resourceName: '*',
+                    arnFormat: ArnFormat.SLASH_RESOURCE_NAME,
+                }, stack),
+                Arn.format({
+                    service: 'wisdom',
+                    resource: 'message-template',
+                    resourceName: '*',
+                    arnFormat: ArnFormat.SLASH_RESOURCE_NAME,
+                }, stack),
+            ],
+        }));
+        // ---- Invoke resource policy for Amazon Connect ------------------------
+        // A Connect Journey Custom-action (and Outbound Campaigns v2) invokes this
+        // Lambda through the connect / connect-campaigns service principal. Grant
+        // lambda:InvokeFunction to both, scoped to THIS account (`sourceAccount`) so
+        // only Connect instances in the deploying account — not any Connect instance
+        // anywhere — can invoke it (confused-deputy guard). The Connect instance ARN
+        // isn't known at synth time, so account scoping is the tightest guard here.
+        for (const servicePrincipal of CONNECT_INVOKE_SERVICE_PRINCIPALS) {
+            pushFn.addPermission(`Invoke-${servicePrincipal.replace(/[^a-zA-Z0-9]/g, '-')}`, {
+                principal: new iam.ServicePrincipal(servicePrincipal),
+                action: 'lambda:InvokeFunction',
+                sourceAccount: stack.account,
+            });
+        }
+        this.pushFunctionArn = pushFn.functionArn;
+        // Scoped to the stack (not `this`) so the output keeps a stable, readable
+        // logical id (`PushHandlerFunctionArn`) that a human can find in the
+        // CloudFormation console and copy to wire the Journey Custom-action.
+        new CfnOutput(stack, 'PushHandlerFunctionArn', {
+            value: pushFn.functionArn,
+            description: 'Wire as a Connect Journey Custom-action (Invoke Lambda) target',
+        });
+        // ---- Create-mode outputs ----------------------------------------------
+        // Surface the resources this construct provisioned from scratch so a human
+        // can find the new instance / domain in the console. Their Outbound
+        // Campaigns association is handled automatically by the custom resource above.
+        if (connectInstance) {
+            new CfnOutput(stack, 'ConnectInstanceId', {
+                value: connectInstance.attrId,
+                description: 'Amazon Connect instance created for notifications',
+            });
+            new CfnOutput(stack, 'ConnectInstanceArn', {
+                value: connectInstance.attrArn,
+                description: 'Amazon Connect instance ARN',
+            });
+        }
+        if (profilesDomain) {
+            new CfnOutput(stack, 'ProfilesDomainName', {
+                value: domainName,
+                description: 'Customer Profiles domain created for notifications',
+            });
+        }
+        this.resources = {
+            identifyUserFunction: fn,
+            httpApi,
+            profileObjectType: profileType,
+            guestProfileObjectType: guestProfileType,
+            deviceObjectType: deviceType,
+            pushFunction: pushFn,
+            pushApplication,
+            apnsChannel,
+            gcmChannel,
+            connectInstance,
+            profilesDomain,
+        };
+    }
+    /**
+     * Create-from-scratch ONLY: a Lambda-backed CDK custom resource that
+     * associates the created Customer Profiles domain with the created Amazon
+     * Connect instance's Outbound Campaigns v2 at deploy time, so Connect Journeys
+     * can target the domain's profiles with no manual console step.
+     *
+     * A `custom-resources.Provider` fronts the handler because onboarding is
+     * asynchronous: the handler starts the instance-onboarding job, then POLLS
+     * GetInstanceOnboardingJobStatus until SUCCEEDED (an `AwsCustomResource` can't
+     * poll). onCreate/onUpdate are idempotent; onDelete best-effort reverses the
+     * integrations + offboards, never failing teardown. The resource depends on
+     * both the instance and the domain so it runs after they exist and is torn
+     * down before them.
+     */
+    addCampaignAssociation(connectInstance, profilesDomain, domainName, codePath) {
+        const stack = this.stack;
+        const associationFn = new lambda.Function(this, 'CampaignAssociationFn', {
+            code: lambda.Code.fromAsset(codePath),
+            handler: 'index.handler',
+            runtime: lambda.Runtime.NODEJS_20_X,
+            // Onboarding polls GetInstanceOnboardingJobStatus until SUCCEEDED (~20s,
+            // capped ~2min); allow generous headroom for onboarding + both integrations.
+            timeout: Duration.minutes(10),
+            memorySize: 256,
+        });
+        // These instance-onboarding / instance-integration actions operate on the
+        // Connect instance's Outbound Campaigns configuration, not on a campaign
+        // resource. connect-campaigns does NOT support resource-level permissions
+        // for them (IAM evaluates them against `campaign/*` and denies an
+        // `instance/*`-scoped grant), so they must be granted on `*`.
+        associationFn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: [
+                'connect-campaigns:StartInstanceOnboardingJob',
+                'connect-campaigns:GetInstanceOnboardingJobStatus',
+                'connect-campaigns:DeleteInstanceOnboardingJob',
+                'connect-campaigns:PutConnectInstanceIntegration',
+                'connect-campaigns:DeleteConnectInstanceIntegration',
+            ],
+            resources: ['*'],
+        }));
+        // connect-campaigns onboarding + PutConnectInstanceIntegration validate the
+        // target Connect instance on the caller's behalf, so the handler role also
+        // needs connect:DescribeInstance on the (construct-owned) instance.
+        associationFn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: ['connect:DescribeInstance'],
+            resources: [connectInstance.attrArn],
+        }));
+        // Reciprocal Customer Profiles integration on THIS domain only (IAM prefix
+        // for Customer Profiles is `profile`). GetDomain is read-only and required
+        // because PutConnectInstanceIntegration validates the Customer Profiles
+        // domain before wiring the integration.
+        const domainArn = Arn.format({
+            service: 'profile',
+            resource: 'domains',
+            resourceName: domainName,
+            arnFormat: ArnFormat.SLASH_RESOURCE_NAME,
+        }, stack);
+        associationFn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: [
+                'profile:PutIntegration',
+                'profile:DeleteIntegration',
+                'profile:GetDomain',
+            ],
+            resources: [
+                domainArn,
+                Arn.format({
+                    service: 'profile',
+                    resource: 'domains',
+                    resourceName: `${domainName}/integrations/*`,
+                    arnFormat: ArnFormat.SLASH_RESOURCE_NAME,
+                }, stack),
+            ],
+        }));
+        // PutConnectInstanceIntegration validates the four built-in campaign
+        // object-type TEMPLATES referenced by objectTypeNames (Campaign-Email,
+        // Campaign-SMS, Campaign-Telephony, Campaign-Orchestration) via
+        // profile:GetProfileObjectTypeTemplate, using the CALLER's credentials.
+        // Templates are account/region-level resources whose ARN carries a leading
+        // slash (`:/templates/<name>`), distinct from the domain, so they need their
+        // own grant.
+        const profileTemplatesArn = `arn:${stack.partition}:profile:${stack.region}:${stack.account}:/templates/*`;
+        associationFn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: [
+                'profile:GetProfileObjectTypeTemplate',
+                'profile:ListProfileObjectTypeTemplates',
+            ],
+            resources: [profileTemplatesArn],
+        }));
+        // Onboarding auto-creates the Outbound Campaigns service-linked role; the
+        // handler then lists roles to resolve its ARN. iam:ListRoles has no
+        // resource-level scoping, so it must target `*`.
+        associationFn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: ['iam:ListRoles'],
+            resources: ['*'],
+        }));
+        // Each StartInstanceOnboardingJob for a NEW Connect instance creates its own
+        // connect-campaigns service-linked role (the role name carries a
+        // service-generated random suffix), so the grant must use `*` for the
+        // resource and is instead scoped safely by the iam:AWSServiceName condition
+        // to ONLY the connect-campaigns SLR. A path-scoped resource ARN is denied by
+        // IAM here (surfaced as the onboarding job's IAM_ACCESS_DENIED failureCode).
+        const campaignsSlrArn = `arn:${stack.partition}:iam::${stack.account}:role/aws-service-role/${CONNECT_CAMPAIGNS_SERVICE_NAME}/*`;
+        associationFn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: ['iam:CreateServiceLinkedRole'],
+            resources: ['*'],
+            conditions: {
+                StringEquals: {
+                    'iam:AWSServiceName': CONNECT_CAMPAIGNS_SERVICE_NAME,
+                },
+            },
+        }));
+        associationFn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: ['iam:PassRole'],
+            resources: [campaignsSlrArn],
+        }));
+        // During onboarding, connect-campaigns customizes its service-linked role
+        // with instance-specific inline permissions (the "additional permissions
+        // added for the service-linked role to access the resources", incl. the
+        // Customer Profiles integration access) via iam:PutRolePolicy /
+        // iam:AttachRolePolicy, performed with the CALLER's credentials. Without
+        // these the onboarding job fails with failureCode IAM_ACCESS_DENIED. The
+        // reverse (Delete/Detach) mirrors this so the best-effort teardown can
+        // remove those inline permissions when disassociating. Scoped to ONLY the
+        // connect-campaigns service-linked role.
+        associationFn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: [
+                'iam:PutRolePolicy',
+                'iam:AttachRolePolicy',
+                'iam:DeleteRolePolicy',
+                'iam:DetachRolePolicy',
+            ],
+            resources: [campaignsSlrArn],
+        }));
+        // Onboarding also provisions a managed EventBridge rule (named
+        // `ConnectCampaignsRule*`) that drives campaign event delivery, created with
+        // the CALLER's credentials. Without these the onboarding job fails with
+        // failureCode EVENT_BRIDGE_ACCESS_DENIED. ListRules has no resource-level
+        // scoping; the mutating actions are scoped to the ConnectCampaignsRule* name.
+        const connectCampaignsRuleArn = `arn:${stack.partition}:events:${stack.region}:${stack.account}:rule/ConnectCampaignsRule*`;
+        associationFn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: ['events:ListRules'],
+            resources: ['*'],
+        }));
+        associationFn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: [
+                'events:PutRule',
+                'events:PutTargets',
+                'events:DeleteRule',
+                'events:RemoveTargets',
+                'events:ListTargetsByRule',
+                'events:DescribeRule',
+            ],
+            resources: [connectCampaignsRuleArn],
+        }));
+        const provider = new Provider(this, 'CampaignAssociationProvider', {
+            onEventHandler: associationFn,
+        });
+        const association = new CustomResource(this, 'CampaignAssociation', {
+            serviceToken: provider.serviceToken,
+            resourceType: 'Custom::OutboundCampaignsDomainAssociation',
+            properties: {
+                ConnectInstanceId: connectInstance.attrId,
+                DomainName: domainName,
+                Account: stack.account,
+                Region: stack.region,
+            },
+        });
+        // Provision after — and tear down before — the instance + domain it links.
+        association.node.addDependency(connectInstance);
+        association.node.addDependency(profilesDomain);
+    }
+    /**
+     * Deterministic, stable, per-app base name for the created Connect instance
+     * and Customer Profiles domain (create-from-scratch mode).
+     *
+     * The name must be STABLE across deploy and delete (so CFN resolves the same
+     * resource on teardown) and UNIQUE per app / environment (so two apps in the
+     * same account don't collide on the globally-unique Connect alias). It is
+     * derived from a short hash of the root stack name (which, in Amplify Gen2,
+     * embeds the app namespace + branch) plus this construct's path — both stable
+     * inputs.
+     *
+     * The `amazon-connect-` prefix is REQUIRED, not cosmetic: Amazon Connect's
+     * AWS-managed service-linked-role policy (`AmazonConnectServiceLinkedRolePolicy`,
+     * statement `AllowCustomerProfilesForConnectDomain`) grants the instance's
+     * role `profile:*` ONLY on `arn:aws:profile:*:*:domains/amazon-connect-*`. A
+     * domain named otherwise is unreachable by the instance — the Connect console
+     * and Journey segment builder then report "does not have permissions to access
+     * Customer Profiles". The SLR is AWS-protected (no inline policy can be added)
+     * and the managed policy is not editable, so the domain name is the only lever.
+     */
+    generateResourceName() {
+        let root = this.stack;
+        while (root.nestedStackParent) {
+            root = root.nestedStackParent;
+        }
+        const seed = `${root.stackName}::${this.node.path}`;
+        const suffix = createHash('sha256').update(seed).digest('hex').slice(0, 12);
+        return `amazon-connect-notifications-${suffix}`;
+    }
+    /**
+     * Coerce an arbitrary string into a valid Amazon Connect instance alias:
+     * lowercase alphanumeric characters + single hyphens, no leading/trailing hyphen, not
+     * starting with the reserved `d-` prefix, and within Connect's 1–62 char
+     * bound.
+     */
+    sanitizeInstanceAlias(raw) {
+        let alias = raw
+            .toLowerCase()
+            .replace(/[^a-z0-9-]/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-+|-+$/g, '');
+        if (alias.startsWith('d-')) {
+            alias = `a${alias}`;
+        }
+        if (alias.length === 0) {
+            alias = 'amplify-notifications';
+        }
+        return alias.slice(0, 62).replace(/-+$/g, '');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"construct.js","sourceRoot":"","sources":["../src/construct.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport { createHash } from 'node:crypto';\nimport { fileURLToPath } from 'node:url';\nimport {\n  Arn,\n  ArnFormat,\n  CfnOutput,\n  CustomResource,\n  Duration,\n  Stack,\n} from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { Provider } from 'aws-cdk-lib/custom-resources';\nimport {\n  CfnDomain,\n  CfnIntegration,\n  CfnObjectType,\n} from 'aws-cdk-lib/aws-customerprofiles';\nimport {\n  CfnInstance,\n  CfnIntegrationAssociation,\n} from 'aws-cdk-lib/aws-connect';\nimport { CfnKnowledgeBase } from 'aws-cdk-lib/aws-wisdom';\nimport {\n  CfnAPNSChannel,\n  CfnAPNSSandboxChannel,\n  CfnApp,\n  CfnGCMChannel,\n} from 'aws-cdk-lib/aws-pinpoint';\nimport * as apigwv2 from 'aws-cdk-lib/aws-apigatewayv2';\nimport {\n  HttpIamAuthorizer,\n  HttpJwtAuthorizer,\n} from 'aws-cdk-lib/aws-apigatewayv2-authorizers';\nimport { HttpLambdaIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';\nimport { ResourceProvider, StackProvider } from '@aws-amplify/plugin-types';\n\nimport {\n  CONNECT_CAMPAIGNS_SERVICE_NAME,\n  CONNECT_INVOKE_SERVICE_PRINCIPALS,\n  DEFAULT_EXPIRATION_DAYS,\n  ENV_DOMAIN_NAME,\n  ENV_EUM_APPLICATION_ID,\n} from './constants.js';\nimport {\n  AMPLIFY_DEVICE_FIELDS,\n  AMPLIFY_DEVICE_KEYS,\n  AMPLIFY_GUEST_PROFILE_FIELDS,\n  AMPLIFY_GUEST_PROFILE_KEYS,\n  AMPLIFY_PROFILE_FIELDS,\n  AMPLIFY_PROFILE_KEYS,\n  OBJECT_TYPE_NAMES,\n} from './object_types.js';\n\n/**\n * The pre-bundled identify-user Lambda asset ships alongside the compiled\n * construct at `<packageRoot>/lib/handler-asset` (produced by the package's\n * `post:compile` esbuild step). Resolving relative to the package root — rather\n * than to this module — means the path is correct whether the code runs from\n * the compiled `lib/` output or from `src/` under `tsx` (as the unit tests do).\n */\nconst packageRoot = fileURLToPath(new URL('..', import.meta.url));\nconst defaultLambdaCodePath = path.join(packageRoot, 'lib', 'handler-asset');\nconst defaultPushLambdaCodePath = path.join(\n  packageRoot,\n  'lib',\n  'push-handler-asset',\n);\nconst defaultCampaignAssociationLambdaCodePath = path.join(\n  packageRoot,\n  'lib',\n  'campaign-association-asset',\n);\n\n/** CDK resources exposed by {@link AmplifyNotifications}. */\nexport type NotificationsResources = {\n  /** The identify-user Lambda function. */\n  identifyUserFunction: lambda.IFunction;\n  /** The HTTP API fronting the identify-user route. */\n  httpApi: apigwv2.HttpApi;\n  /** The AmplifyProfile object type registered on the domain. */\n  profileObjectType: CfnObjectType;\n  /** The AmplifyGuestProfile object type registered on the domain. */\n  guestProfileObjectType: CfnObjectType;\n  /** The AmplifyDevice object type registered on the domain. */\n  deviceObjectType: CfnObjectType;\n  /**\n   * The push-delivery Lambda function, wired as the target of a Connect Journey\n   * Custom-action (Invoke Lambda).\n   */\n  pushFunction: lambda.IFunction;\n  /** The AWS End User Messaging / Pinpoint application backing push delivery. */\n  pushApplication: CfnApp;\n  /**\n   * The APNs channel enabled on the push application, when `apnsChannel` is\n   * configured. `undefined` when no APNs configuration was provided. Either the\n   * production (`CfnAPNSChannel`) or sandbox (`CfnAPNSSandboxChannel`) channel,\n   * depending on `apnsChannel.sandbox`.\n   */\n  apnsChannel?: CfnAPNSChannel | CfnAPNSSandboxChannel;\n  /**\n   * The GCM/FCM channel enabled on the push application, when `fcmChannel` is\n   * configured. `undefined` when no FCM configuration was provided.\n   */\n  gcmChannel?: CfnGCMChannel;\n  /**\n   * The Amazon Connect instance created in create-from-scratch mode (when\n   * `domainName` is omitted). `undefined` in attach mode.\n   */\n  connectInstance?: CfnInstance;\n  /**\n   * The Customer Profiles domain created in create-from-scratch mode (when\n   * `domainName` is omitted). `undefined` in attach mode, where the object types\n   * are registered into a pre-existing domain the construct does not own.\n   */\n  profilesDomain?: CfnDomain;\n};\n\nexport type AmplifyNotificationsProps = {\n  /**\n   * The JWT issuer URL the HTTP API authorizer trusts. For a Cognito user pool\n   * this is `https://cognito-idp.<region>.amazonaws.com/<userPoolId>`.\n   */\n  readonly jwtIssuer: string;\n\n  /**\n   * Allowed JWT audiences. For a Cognito user pool this is the app client id(s)\n   * (matched against `aud` for id tokens / `client_id` for access tokens).\n   */\n  readonly jwtAudience: string[];\n\n  /**\n   * Name of an EXISTING Customer Profiles domain to attach to — e.g. the domain\n   * Amazon Connect auto-creates when Customer Profiles is enabled on an\n   * instance. When provided, the construct runs in ATTACH mode: it registers the\n   * AmplifyProfile / AmplifyDevice object types INTO this domain and never\n   * creates an instance or a domain.\n   *\n   * OMIT this to run in the default CREATE-FROM-SCRATCH mode: the construct\n   * provisions a brand-new Amazon Connect instance AND a brand-new Customer\n   * Profiles domain (with generated, stable names) and wires everything into\n   * that new domain — so a caller needs zero pre-existing Connect setup.\n   */\n  readonly domainName?: string;\n\n  /**\n   * CREATE mode only: override the auto-generated Amazon Connect instance alias.\n   * Ignored in attach mode. When omitted, a deterministic-yet-unique alias is\n   * derived from the construct's scope so it is stable across deploy/delete and\n   * unique per app. Lowercase alphanumeric characters + hyphens; must not start\n   * with\n   * `d-`.\n   */\n  readonly instanceAlias?: string;\n\n  /**\n   * Override the directory containing the pre-bundled Lambda asset (an\n   * `index.js` exporting `handler`). Defaults to the handler bundled inside this\n   * package (`lib/handler-asset`, produced by `post:compile`).\n   */\n  readonly lambdaCodePath?: string;\n\n  /** Profile / object-type expiration in days. Default: 366. */\n  readonly expirationDays?: number;\n\n  /**\n   * Override the directory containing the pre-bundled push Lambda asset (an\n   * `index.js` exporting `handler`). Defaults to the handler bundled inside this\n   * package (`lib/push-handler-asset`, produced by `post:compile`).\n   */\n  readonly pushLambdaCodePath?: string;\n\n  /**\n   * Override the directory containing the pre-bundled campaign-association\n   * custom-resource Lambda asset (an `index.js` exporting `handler`). Defaults to\n   * the handler bundled inside this package (`lib/campaign-association-asset`,\n   * produced by `post:compile`). Only used in create-from-scratch mode.\n   */\n  readonly campaignAssociationLambdaCodePath?: string;\n\n  /**\n   * OPTIONAL APNs channel configuration (token / `.p8` auth). When provided, the\n   * construct enables the APNs channel on the created End User Messaging\n   * (Pinpoint) application. All values are plain strings — the Amplify Gen2\n   * factory resolves the `.p8` key from an Amplify `secret()` before passing it\n   * here, keeping this construct framework-agnostic. When omitted, no APNs\n   * channel is configured.\n   */\n  readonly apnsChannel?: {\n    /** The APNs token signing key contents (the `AuthKey_<keyId>.p8` file). */\n    readonly tokenKey: string;\n    /** The 10-character key identifier assigned to the APNs signing key. */\n    readonly keyId: string;\n    /** The Apple Developer account team identifier. */\n    readonly teamId: string;\n    /** The iOS app bundle identifier. */\n    readonly bundleId: string;\n    /**\n     * Configure the APNs **sandbox** channel instead of the production channel.\n     * @default false\n     */\n    readonly sandbox?: boolean;\n  };\n\n  /**\n   * OPTIONAL FCM/GCM channel configuration (FCM HTTP v1 auth). When provided, the\n   * construct enables the GCM channel on the created End User Messaging\n   * (Pinpoint) application. The value is a plain string — the Amplify Gen2\n   * factory resolves the service-account JSON from an Amplify `secret()` before\n   * passing it here. When omitted, no GCM channel is configured.\n   */\n  readonly fcmChannel?: {\n    /** The FCM HTTP v1 service-account JSON credential contents. */\n    readonly serviceJson: string;\n  };\n};\n\n/**\n * Amazon Connect Customer Profiles backend for the identifyUser contract,\n * packaged as an AWS CDK construct. Provisions:\n *   - AmplifyProfile object type: searchable `cognitoUserKey` (PROFILE + UNIQUE)\n *     identity key + person / targeting attribute schema.\n *   - AmplifyDevice object type: PROFILE-resolution key = `cognitoUserKey`,\n *     UNIQUE object key = stable `deviceId`; device fields stored raw.\n *   - identify-user Lambda with least-privilege profile:* on this domain only.\n *   - HTTP API + JWT authorizer bound to the supplied issuer / audience.\n *   - push-delivery Lambda (Connect Journey Custom-action target) + a minimal\n *     AWS End User Messaging (Pinpoint) application for `SendMessages`.\n *\n * It operates in one of two modes, chosen by whether `domainName` is provided:\n *\n *   - CREATE-FROM-SCRATCH (default, `domainName` omitted): the construct also\n *     provisions a brand-new Amazon Connect instance (`AWS::Connect::Instance`,\n *     CONNECT_MANAGED, inbound/outbound enabled) AND a brand-new Customer\n *     Profiles domain (`AWS::CustomerProfiles::Domain`) with generated, stable\n *     names, then registers the object types INTO that new domain. The object\n *     types depend on the created domain so they provision after it and are torn\n *     down before it. A caller needs zero pre-existing Connect setup.\n *   - ATTACH (`domainName` provided): the construct registers the two object\n *     types INTO the existing `domainName` (additive) — such as the domain\n *     Amazon Connect auto-creates when Customer Profiles is enabled on an\n *     instance — WITHOUT creating an instance or a domain, and without touching\n *     the domain's other integrations (CTR, Outbound Campaigns) or its Identity\n *     Resolution setting.\n *\n * In either mode, identify works against the domain standalone. Outbound\n * Campaigns association — so journeys can target these profiles — is AUTOMATIC\n * in create-from-scratch mode (a Lambda-backed custom resource associates the\n * new domain with the new instance's Outbound Campaigns v2 at deploy time). In\n * attach mode, associating the pre-existing domain is the user's responsibility\n * and is left untouched.\n *\n * This construct is framework-agnostic (aws-cdk-lib + constructs only). The\n * `defineNotifications` factory wraps it for Amplify Gen2 backends, wiring the\n * JWT authorizer to the app's Cognito user pool and surfacing the endpoint via\n * backend outputs.\n */\nexport class AmplifyNotifications\n  extends Construct\n  implements ResourceProvider<NotificationsResources>, StackProvider\n{\n  /** CDK resources for lower-level access. */\n  public readonly resources: NotificationsResources;\n  /** The stack this construct belongs to. */\n  public readonly stack: Stack;\n  /** Base invoke URL. Clients call `POST {apiEndpoint}/identify-user`. */\n  public readonly apiEndpoint: string;\n  /** The route path appended to {@link apiEndpoint}. */\n  public readonly identifyUserPath = '/identify-user';\n  /**\n   * The GUEST route path appended to {@link apiEndpoint}.\n   * IAM/SigV4-authorized; unauthenticated Identity Pool callers sign requests to\n   * `POST {apiEndpoint}/identify-user-guest`.\n   */\n  public readonly guestIdentifyUserPath = '/identify-user-guest';\n  /**\n   * The `execute-api:Invoke` ARN of the GUEST route, to\n   * grant to the app's Cognito Identity Pool UNAUTHENTICATED role so guests can\n   * call the route. Scoped to POST on the guest path of this API's default\n   * stage.\n   */\n  public readonly guestRouteInvokeArn!: string;\n  /** The Customer Profiles domain name the object types are registered into. */\n  public readonly domainName: string;\n  /**\n   * `true` when this construct created the Customer Profiles domain + Connect\n   * instance (create-from-scratch mode); `false` when it attached to an existing\n   * domain named by `domainName`.\n   */\n  public readonly createsResources: boolean;\n  /**\n   * Id of the Amazon Connect instance created in create-from-scratch mode.\n   * `undefined` in attach mode.\n   */\n  public readonly connectInstanceId?: string;\n  /**\n   * ARN of the Amazon Connect instance created in create-from-scratch mode.\n   * `undefined` in attach mode.\n   */\n  public readonly connectInstanceArn?: string;\n  /**\n   * ARN of the push-delivery Lambda, to wire as a Connect Journey Custom-action\n   * (Invoke Lambda) target.\n   */\n  public readonly pushFunctionArn: string;\n  /**\n   * The AWS End User Messaging / Pinpoint application id this construct created\n   * and the push Lambda calls `SendMessages` against.\n   */\n  public readonly eumApplicationId: string;\n\n  /**\n   * Registers the AmplifyProfile / AmplifyDevice object types into the Customer\n   * Profiles domain (created here in create-from-scratch mode, or the existing\n   * `domainName` in attach mode), the identify-user Lambda + JWT-authorized HTTP\n   * API, and the push-delivery Lambda + AWS End User Messaging application for\n   * this notifications backend.\n   */\n  constructor(scope: Construct, id: string, props: AmplifyNotificationsProps) {\n    super(scope, id);\n\n    const stack = Stack.of(this);\n    this.stack = stack;\n    const expirationDays = props.expirationDays ?? DEFAULT_EXPIRATION_DAYS;\n\n    // ---- Mode selection: create-from-scratch (default) vs attach -----------\n    // If a `domainName` is supplied, ATTACH the object types to that existing\n    // domain (create nothing). Otherwise (the zero-config default) CREATE a\n    // brand-new Connect instance + Customer Profiles domain with generated,\n    // stable names and register the object types into the new domain.\n    const createFromScratch = !props.domainName;\n    this.createsResources = createFromScratch;\n\n    let domainName: string;\n    let profilesDomain: CfnDomain | undefined;\n    let connectInstance: CfnInstance | undefined;\n\n    if (createFromScratch) {\n      // Deterministic-yet-unique base name derived from the construct's scope so\n      // it is STABLE across deploy/delete (same tree → same name) and unique per\n      // app / environment (the root stack name embeds the Amplify app + branch).\n      const baseName = this.generateResourceName();\n      domainName = baseName;\n\n      connectInstance = new CfnInstance(this, 'ConnectInstance', {\n        // Minimal telephony surface: Connect requires at least one of\n        // inbound/outbound; enable both so the instance is usable for outbound\n        // journeys later. Directory is Connect-managed (no external identity).\n        //\n        // highVolumeOutBound enables the instance's Outbound Campaigns feature.\n        // This is what makes Amazon Connect attach the\n        // `HighVolumeOutboundCommunicationAccess` inline policy to the instance's\n        // OWN service-linked role — the policy granting the `connect-campaigns:*`\n        // (CreateCampaign / ListCampaigns / ...) actions the Connect console\n        // drives Journey + campaign authoring through. Onboarding to Outbound\n        // Campaigns v2 (the campaign-association custom resource) does NOT set\n        // it, so without this the console's Journey / segment builder fails with\n        // connect-campaigns AccessDenied on the instance SLR.\n        attributes: {\n          inboundCalls: true,\n          outboundCalls: true,\n          highVolumeOutBound: true,\n        },\n        identityManagementType: 'CONNECT_MANAGED',\n        instanceAlias: this.sanitizeInstanceAlias(\n          props.instanceAlias ?? baseName,\n        ),\n      });\n\n      profilesDomain = new CfnDomain(this, 'ProfilesDomain', {\n        domainName,\n        defaultExpirationDays: expirationDays,\n      });\n\n      this.connectInstanceId = connectInstance.attrId;\n      this.connectInstanceArn = connectInstance.attrArn;\n\n      // Instance-level Customer Profiles feature binding: registers the created\n      // domain as the instance's CTR (contact-record) profiles store — the\n      // \"Customer Profiles enabled\" integration the Connect console and Journey\n      // segment builder require, distinct from the Outbound Campaigns\n      // integration the association custom resource wires below. PutIntegration\n      // auto-resolves the Connect service-linked role for a connect-instance\n      // URI; that SLR can only reach the domain because it is named\n      // `amazon-connect-*` (see generateResourceName).\n      const ctrIntegration = new CfnIntegration(\n        this,\n        'ConnectProfilesIntegration',\n        {\n          domainName,\n          uri: connectInstance.attrArn,\n          objectTypeName: 'CTR',\n        },\n      );\n      ctrIntegration.addDependency(connectInstance);\n      ctrIntegration.addDependency(profilesDomain);\n\n      // Message-templates knowledge base + its instance association. Both the\n      // Connect console's message-template authoring UI and the push-delivery\n      // Lambda's runtime discovery (ListIntegrationAssociations filtered to\n      // Q_MESSAGE_TEMPLATES → the KB it renders templates from) require a\n      // MESSAGE_TEMPLATES knowledge base linked to the instance. We provision\n      // the empty KB + the Q_MESSAGE_TEMPLATES association only; the templates\n      // themselves are the marketer's job (a template's name must match the\n      // journey Custom-action id, e.g. \"Push Notification\"). A MESSAGE_TEMPLATES\n      // KB needs no Q assistant. The name is derived from the same deterministic\n      // base as the instance/domain so redeploys stay stable and avoid the\n      // CreateKnowledgeBase ConflictException on duplicate names.\n      const templatesKb = new CfnKnowledgeBase(this, 'MessageTemplatesKb', {\n        name: `${baseName}-message-templates`,\n        knowledgeBaseType: 'MESSAGE_TEMPLATES',\n      });\n\n      const templatesAssociation = new CfnIntegrationAssociation(\n        this,\n        'MessageTemplatesAssociation',\n        {\n          instanceId: connectInstance.attrArn,\n          integrationType: 'Q_MESSAGE_TEMPLATES',\n          integrationArn: templatesKb.attrKnowledgeBaseArn,\n        },\n      );\n      templatesAssociation.addDependency(connectInstance);\n      templatesAssociation.addDependency(templatesKb);\n    } else {\n      domainName = props.domainName as string;\n    }\n    this.domainName = domainName;\n\n    // ---- Object types ------------------------------------------------------\n    // Registered INTO `domainName`. In attach mode this is purely additive to a\n    // pre-existing (e.g. Connect-managed) domain. In create mode the object\n    // types depend on the domain created above, so CFN provisions the domain\n    // first and — on teardown — removes the object types before the domain (a\n    // clean, in-construct dependency; no cross-stack ordering hack needed).\n    const profileType = new CfnObjectType(this, 'AmplifyProfileType', {\n      domainName,\n      objectTypeName: OBJECT_TYPE_NAMES.profile,\n      description:\n        'Amplify identifyUser person profile (find-or-create by verified Cognito sub)',\n      allowProfileCreation: true,\n      fields: AMPLIFY_PROFILE_FIELDS,\n      keys: AMPLIFY_PROFILE_KEYS,\n      expirationDays,\n    });\n\n    const deviceType = new CfnObjectType(this, 'AmplifyDeviceType', {\n      domainName,\n      objectTypeName: OBJECT_TYPE_NAMES.device,\n      description:\n        'Amplify identifyUser device (unique per stable deviceId; token is a mutable field; resolves to profile by cognitoUserKey)',\n      allowProfileCreation: true,\n      fields: AMPLIFY_DEVICE_FIELDS,\n      keys: AMPLIFY_DEVICE_KEYS,\n      expirationDays,\n    });\n\n    // A distinct object type for GUEST profiles. Customer\n    // Profiles permits exactly one UNIQUE key per object type and PutProfileObject\n    // requires the ingested object to carry it; the authed AmplifyProfile reserves\n    // its UNIQUE key for cognitoSub, so guest profiles (keyed on the Identity Pool\n    // cognitoIdentityId) get their own type with cognitoIdentityKey as UNIQUE.\n    const guestProfileType = new CfnObjectType(\n      this,\n      'AmplifyGuestProfileType',\n      {\n        domainName,\n        objectTypeName: OBJECT_TYPE_NAMES.guestProfile,\n        description:\n          'Amplify identifyUser GUEST person profile (find-or-create by verified Cognito Identity Pool identityId)',\n        allowProfileCreation: true,\n        fields: AMPLIFY_GUEST_PROFILE_FIELDS,\n        keys: AMPLIFY_GUEST_PROFILE_KEYS,\n        expirationDays,\n      },\n    );\n\n    if (profilesDomain) {\n      profileType.addDependency(profilesDomain);\n      deviceType.addDependency(profilesDomain);\n      guestProfileType.addDependency(profilesDomain);\n    }\n\n    // ---- Outbound Campaigns association (create-from-scratch ONLY) ----------\n    // When this construct created the instance + domain, a Lambda-backed custom\n    // resource associates the new domain with the instance's Outbound Campaigns\n    // v2 at deploy time — so Connect Journeys can target the domain's profiles\n    // with NO manual console step. In attach mode the existing domain's\n    // association is the user's responsibility, so this resource is NOT added.\n    if (createFromScratch && connectInstance && profilesDomain) {\n      this.addCampaignAssociation(\n        connectInstance,\n        profilesDomain,\n        domainName,\n        props.campaignAssociationLambdaCodePath ??\n          defaultCampaignAssociationLambdaCodePath,\n      );\n    }\n\n    // ---- Lambda handler ----------------------------------------------------\n    // Pre-bundled at build time (esbuild) into a self-contained asset, so the\n    // construct works regardless of the consuming project's root (Amplify's\n    // NodejsFunction guardrail forbids an entry outside the app root).\n    const codePath = props.lambdaCodePath ?? defaultLambdaCodePath;\n\n    const fn = new lambda.Function(this, 'IdentifyUserFn', {\n      code: lambda.Code.fromAsset(codePath),\n      handler: 'index.handler',\n      runtime: lambda.Runtime.NODEJS_20_X,\n      timeout: Duration.seconds(15),\n      memorySize: 256,\n      environment: {\n        [ENV_DOMAIN_NAME]: domainName,\n      },\n    });\n\n    // ---- Least-privilege IAM ----------------------------------------------\n    const domainArn = Arn.format(\n      {\n        service: 'profile',\n        resource: 'domains',\n        resourceName: domainName,\n        arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n      },\n      stack,\n    );\n    const objectTypesArn = Arn.format(\n      {\n        service: 'profile',\n        resource: 'domains',\n        resourceName: `${domainName}/object-types/*`,\n        arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n      },\n      stack,\n    );\n    fn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          // PutProfileObject find-or-create (AmplifyProfile) + read-back.\n          'profile:PutProfileObject',\n          'profile:SearchProfiles',\n          // Read back the existing device object to preserve immutable createdAt.\n          'profile:ListProfileObjects',\n          // Set targeting / person attributes on the resolved profile.\n          'profile:UpdateProfile',\n        ],\n        resources: [domainArn, objectTypesArn],\n      }),\n    );\n\n    // Merge-on-sign-in folds a prior guest profile\n    // (+ its device objects) into the authed profile via MergeProfiles.\n    // NOTE: the Service Authorization Reference lists MergeProfiles under the\n    // `domains` resource type, but the service ACTUALLY authorizes it against\n    // an undocumented, differently-shaped resource ARN (note the leading slash\n    // and the /profiles/objects/merge suffix):\n    //   arn:<partition>:profile:<region>:<account>:/domains/<domain>/profiles/objects/merge\n    // Granting the documented domain ARN is NOT sufficient. This dedicated\n    // statement targets the enforced resource.\n    const mergeProfilesArn = `arn:${stack.partition}:profile:${stack.region}:${stack.account}:/domains/${domainName}/profiles/objects/merge`;\n    fn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: ['profile:MergeProfiles'],\n        resources: [mergeProfilesArn],\n      }),\n    );\n\n    // ---- HTTP API + JWT authorizer ----------------------------------------\n    const authorizer = new HttpJwtAuthorizer('JwtAuthorizer', props.jwtIssuer, {\n      jwtAudience: props.jwtAudience,\n      identitySource: ['$request.header.Authorization'],\n    });\n\n    const httpApi = new apigwv2.HttpApi(this, 'IdentifyUserApi', {\n      apiName: 'identify-user-api',\n      createDefaultStage: true,\n    });\n\n    httpApi.addRoutes({\n      path: this.identifyUserPath,\n      methods: [apigwv2.HttpMethod.POST],\n      integration: new HttpLambdaIntegration('IdentifyUserIntegration', fn),\n      authorizer,\n    });\n\n    // ---- Guest (unauthenticated) route ------------------------------------\n    // A second route to the SAME identify Lambda, but\n    // authorized with IAM/SigV4 instead of a JWT — so an UNAUTHENTICATED Cognito\n    // Identity Pool caller (guest credentials) can register a device / seed a\n    // profile BEFORE login (the pre-login push-token case).\n    //\n    // The integration MUST use payload format 1.0: HTTP API payload format 2.0\n    // has NO `requestContext.identity` block, so the verified Cognito\n    // `cognitoIdentityId` (+ `cognitoAuthenticationType`) the Lambda keys the\n    // guest profile on is only present under format 1.0. The Lambda derives the\n    // guest identity SOLELY from that authorizer-verified field.\n    const iamAuthorizer = new HttpIamAuthorizer();\n    httpApi.addRoutes({\n      path: this.guestIdentifyUserPath,\n      methods: [apigwv2.HttpMethod.POST],\n      integration: new HttpLambdaIntegration('GuestIdentifyIntegration', fn, {\n        payloadFormatVersion: apigwv2.PayloadFormatVersion.VERSION_1_0,\n      }),\n      authorizer: iamAuthorizer,\n    });\n\n    // `execute-api:Invoke` ARN for the guest route — the app grants this to its\n    // Identity Pool UNAUTHENTICATED role so guests can call the route. Scoped as\n    // tightly as execute-api allows: `$default/POST/identify-user-guest` pins the\n    // grant to the POST method on the guest path of the API's single default\n    // stage, so the unauth role can invoke NEITHER other methods, NOR other\n    // stages, NOR the authed `/identify-user` route. (HTTP APIs auto-create the\n    // `$default` stage; this construct never adds another.)\n    this.guestRouteInvokeArn = Arn.format(\n      {\n        service: 'execute-api',\n        resource: httpApi.apiId,\n        resourceName: `$default/POST${this.guestIdentifyUserPath}`,\n        arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n      },\n      stack,\n    );\n\n    this.apiEndpoint = httpApi.apiEndpoint;\n\n    // Scoped to the stack (not `this`) so the output keeps a stable, readable\n    // logical id (`IdentifyUserApiEndpoint`) that a human can find in the\n    // CloudFormation console. The construct is provisioned once per stack (the\n    // Gen2 factory places it in a dedicated nested stack), so there is no\n    // collision risk from the verbatim id.\n    new CfnOutput(stack, 'IdentifyUserApiEndpoint', {\n      value: httpApi.apiEndpoint,\n      description: 'POST {value}/identify-user',\n    });\n\n    // Surface the guest route's invoke ARN so a human /\n    // the app can grant it to the Identity Pool unauthenticated role.\n    new CfnOutput(stack, 'GuestIdentifyRouteInvokeArn', {\n      value: this.guestRouteInvokeArn,\n      description:\n        'Grant execute-api:Invoke on this ARN to the Cognito Identity Pool unauthenticated role',\n    });\n\n    // ---- Push-delivery path -----------------------------------------------\n    // Amazon Connect has no native mobile-push channel, so a Lambda bridges the\n    // gap: Connect invokes it via a Journey Custom-action to deliver push\n    // through AWS End User Messaging (Pinpoint SendMessages). A minimal Pinpoint\n    // application is always created so SendMessages has a valid ApplicationId.\n    // The APNs / GCM channels on it are configured only when the caller supplies\n    // credentials (see `apnsChannel` / `fcmChannel`); otherwise the application\n    // is created with no channel enabled (delivery will 404 until configured).\n    const pushApplication = new CfnApp(this, 'PushApp', {\n      name: `${domainName}-push`,\n    });\n    const eumApplicationId = pushApplication.ref;\n    this.eumApplicationId = eumApplicationId;\n\n    // ---- Optional push channels (secret-driven) ---------------------------\n    // The Amplify Gen2 factory resolves the APNs `.p8` key / FCM service-account\n    // JSON from Amplify `secret()`s to deploy-time CFN tokens and passes them as\n    // plain strings. Channel credentials flow through CloudFormation the same way\n    // Amplify's own external-auth-provider secrets do (defineAuth) — via the\n    // secret custom resource's token, never as literal template plain text. The\n    // channels attach to THIS construct's own EUM app, so they are provisioned\n    // after it and torn down with the stack. The `applicationId` prop resolves to\n    // a `Ref` on the EUM app, so CloudFormation infers the create/delete ordering\n    // — no explicit `addDependency` needed.\n    const { apnsChannel: apnsConfig, fcmChannel: fcmConfig } = props;\n\n    let apnsChannel: CfnAPNSChannel | CfnAPNSSandboxChannel | undefined;\n    if (apnsConfig) {\n      // Token (`.p8`) authentication: the CFN `DefaultAuthenticationMethod`\n      // property accepts `TOKEN` (signing-key auth) or `CERTIFICATE`; token auth\n      // uses the `.p8` signing key. Sandbox selects the development APNs endpoint\n      // used by development-signed builds.\n      const apnsProps = {\n        applicationId: eumApplicationId,\n        enabled: true,\n        defaultAuthenticationMethod: 'TOKEN',\n        tokenKey: apnsConfig.tokenKey,\n        tokenKeyId: apnsConfig.keyId,\n        teamId: apnsConfig.teamId,\n        bundleId: apnsConfig.bundleId,\n      };\n      apnsChannel = apnsConfig.sandbox\n        ? new CfnAPNSSandboxChannel(this, 'ApnsSandboxChannel', apnsProps)\n        : new CfnAPNSChannel(this, 'ApnsChannel', apnsProps);\n    }\n\n    let gcmChannel: CfnGCMChannel | undefined;\n    if (fcmConfig) {\n      // FCM HTTP v1: `TOKEN` auth with a service-account JSON credential. Google\n      // deprecated the legacy server-key (`ApiKey` / `KEY`) API, so only the v1\n      // `ServiceJson` (FCM v1) path is used.\n      gcmChannel = new CfnGCMChannel(this, 'GcmChannel', {\n        applicationId: eumApplicationId,\n        enabled: true,\n        defaultAuthenticationMethod: 'TOKEN',\n        serviceJson: fcmConfig.serviceJson,\n      });\n    }\n\n    const pushCodePath = props.pushLambdaCodePath ?? defaultPushLambdaCodePath;\n    const pushFn = new lambda.Function(this, 'PushHandlerFn', {\n      code: lambda.Code.fromAsset(pushCodePath),\n      handler: 'index.handler',\n      runtime: lambda.Runtime.NODEJS_20_X,\n      timeout: Duration.seconds(30),\n      memorySize: 256,\n      environment: {\n        [ENV_DOMAIN_NAME]: domainName,\n        [ENV_EUM_APPLICATION_ID]: eumApplicationId,\n      },\n    });\n\n    // Least-privilege: read + delete device objects on THIS domain only, and\n    // SendMessages scoped to THIS EUM application.\n    pushFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          // Resolve a profile's registered devices (tokens + channels).\n          'profile:ListProfileObjects',\n          // Stale-token cleanup: delete a device whose token is dead.\n          'profile:DeleteProfileObject',\n        ],\n        resources: [domainArn, objectTypesArn],\n      }),\n    );\n\n    const appMessagesArn = Arn.format(\n      {\n        service: 'mobiletargeting',\n        resource: 'apps',\n        resourceName: `${eumApplicationId}/messages`,\n        arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n      },\n      stack,\n    );\n    pushFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: ['mobiletargeting:SendMessages'],\n        resources: [appMessagesArn],\n      }),\n    );\n\n    // ---- Runtime message-template resolution (Q in Connect) ---------------\n    // The push Lambda resolves per-profile copy from a Q in Connect (Wisdom)\n    // PUSH message template at runtime: it discovers the knowledge base from the\n    // journey's campaign (DescribeCampaign -> connectInstanceId ->\n    // ListIntegrationAssociations) and renders the template whose name matches\n    // the Custom-action ActionId. Least-privilege, scoped to this account /\n    // region. IAM prefixes confirmed empirically: campaign actions use\n    // `connect-campaigns`, integration listing uses `connect`, and Q in Connect\n    // message-template actions use the `wisdom` prefix (Q in Connect is the\n    // rebrand of Amazon Connect Wisdom; the SDK client is `@aws-sdk/client-qconnect`\n    // but IAM/ARNs remain `wisdom`).\n    pushFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: ['connect-campaigns:DescribeCampaign'],\n        resources: [\n          Arn.format(\n            {\n              service: 'connect-campaigns',\n              resource: 'campaign',\n              resourceName: '*',\n              arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n            },\n            stack,\n          ),\n        ],\n      }),\n    );\n    pushFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: ['connect:ListIntegrationAssociations'],\n        resources: [\n          Arn.format(\n            {\n              service: 'connect',\n              resource: 'instance',\n              resourceName: '*',\n              arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n            },\n            stack,\n          ),\n        ],\n      }),\n    );\n    pushFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          'wisdom:ListMessageTemplates',\n          'wisdom:GetMessageTemplate',\n          'wisdom:RenderMessageTemplate',\n        ],\n        resources: [\n          Arn.format(\n            {\n              service: 'wisdom',\n              resource: 'knowledge-base',\n              resourceName: '*',\n              arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n            },\n            stack,\n          ),\n          Arn.format(\n            {\n              service: 'wisdom',\n              resource: 'message-template',\n              resourceName: '*',\n              arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n            },\n            stack,\n          ),\n        ],\n      }),\n    );\n\n    // ---- Invoke resource policy for Amazon Connect ------------------------\n    // A Connect Journey Custom-action (and Outbound Campaigns v2) invokes this\n    // Lambda through the connect / connect-campaigns service principal. Grant\n    // lambda:InvokeFunction to both, scoped to THIS account (`sourceAccount`) so\n    // only Connect instances in the deploying account — not any Connect instance\n    // anywhere — can invoke it (confused-deputy guard). The Connect instance ARN\n    // isn't known at synth time, so account scoping is the tightest guard here.\n    for (const servicePrincipal of CONNECT_INVOKE_SERVICE_PRINCIPALS) {\n      pushFn.addPermission(\n        `Invoke-${servicePrincipal.replace(/[^a-zA-Z0-9]/g, '-')}`,\n        {\n          principal: new iam.ServicePrincipal(servicePrincipal),\n          action: 'lambda:InvokeFunction',\n          sourceAccount: stack.account,\n        },\n      );\n    }\n\n    this.pushFunctionArn = pushFn.functionArn;\n\n    // Scoped to the stack (not `this`) so the output keeps a stable, readable\n    // logical id (`PushHandlerFunctionArn`) that a human can find in the\n    // CloudFormation console and copy to wire the Journey Custom-action.\n    new CfnOutput(stack, 'PushHandlerFunctionArn', {\n      value: pushFn.functionArn,\n      description:\n        'Wire as a Connect Journey Custom-action (Invoke Lambda) target',\n    });\n\n    // ---- Create-mode outputs ----------------------------------------------\n    // Surface the resources this construct provisioned from scratch so a human\n    // can find the new instance / domain in the console. Their Outbound\n    // Campaigns association is handled automatically by the custom resource above.\n    if (connectInstance) {\n      new CfnOutput(stack, 'ConnectInstanceId', {\n        value: connectInstance.attrId,\n        description: 'Amazon Connect instance created for notifications',\n      });\n      new CfnOutput(stack, 'ConnectInstanceArn', {\n        value: connectInstance.attrArn,\n        description: 'Amazon Connect instance ARN',\n      });\n    }\n    if (profilesDomain) {\n      new CfnOutput(stack, 'ProfilesDomainName', {\n        value: domainName,\n        description: 'Customer Profiles domain created for notifications',\n      });\n    }\n\n    this.resources = {\n      identifyUserFunction: fn,\n      httpApi,\n      profileObjectType: profileType,\n      guestProfileObjectType: guestProfileType,\n      deviceObjectType: deviceType,\n      pushFunction: pushFn,\n      pushApplication,\n      apnsChannel,\n      gcmChannel,\n      connectInstance,\n      profilesDomain,\n    };\n  }\n\n  /**\n   * Create-from-scratch ONLY: a Lambda-backed CDK custom resource that\n   * associates the created Customer Profiles domain with the created Amazon\n   * Connect instance's Outbound Campaigns v2 at deploy time, so Connect Journeys\n   * can target the domain's profiles with no manual console step.\n   *\n   * A `custom-resources.Provider` fronts the handler because onboarding is\n   * asynchronous: the handler starts the instance-onboarding job, then POLLS\n   * GetInstanceOnboardingJobStatus until SUCCEEDED (an `AwsCustomResource` can't\n   * poll). onCreate/onUpdate are idempotent; onDelete best-effort reverses the\n   * integrations + offboards, never failing teardown. The resource depends on\n   * both the instance and the domain so it runs after they exist and is torn\n   * down before them.\n   */\n  private addCampaignAssociation(\n    connectInstance: CfnInstance,\n    profilesDomain: CfnDomain,\n    domainName: string,\n    codePath: string,\n  ): void {\n    const stack = this.stack;\n\n    const associationFn = new lambda.Function(this, 'CampaignAssociationFn', {\n      code: lambda.Code.fromAsset(codePath),\n      handler: 'index.handler',\n      runtime: lambda.Runtime.NODEJS_20_X,\n      // Onboarding polls GetInstanceOnboardingJobStatus until SUCCEEDED (~20s,\n      // capped ~2min); allow generous headroom for onboarding + both integrations.\n      timeout: Duration.minutes(10),\n      memorySize: 256,\n    });\n\n    // These instance-onboarding / instance-integration actions operate on the\n    // Connect instance's Outbound Campaigns configuration, not on a campaign\n    // resource. connect-campaigns does NOT support resource-level permissions\n    // for them (IAM evaluates them against `campaign/*` and denies an\n    // `instance/*`-scoped grant), so they must be granted on `*`.\n    associationFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          'connect-campaigns:StartInstanceOnboardingJob',\n          'connect-campaigns:GetInstanceOnboardingJobStatus',\n          'connect-campaigns:DeleteInstanceOnboardingJob',\n          'connect-campaigns:PutConnectInstanceIntegration',\n          'connect-campaigns:DeleteConnectInstanceIntegration',\n        ],\n        resources: ['*'],\n      }),\n    );\n\n    // connect-campaigns onboarding + PutConnectInstanceIntegration validate the\n    // target Connect instance on the caller's behalf, so the handler role also\n    // needs connect:DescribeInstance on the (construct-owned) instance.\n    associationFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: ['connect:DescribeInstance'],\n        resources: [connectInstance.attrArn],\n      }),\n    );\n\n    // Reciprocal Customer Profiles integration on THIS domain only (IAM prefix\n    // for Customer Profiles is `profile`). GetDomain is read-only and required\n    // because PutConnectInstanceIntegration validates the Customer Profiles\n    // domain before wiring the integration.\n    const domainArn = Arn.format(\n      {\n        service: 'profile',\n        resource: 'domains',\n        resourceName: domainName,\n        arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n      },\n      stack,\n    );\n    associationFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          'profile:PutIntegration',\n          'profile:DeleteIntegration',\n          'profile:GetDomain',\n        ],\n        resources: [\n          domainArn,\n          Arn.format(\n            {\n              service: 'profile',\n              resource: 'domains',\n              resourceName: `${domainName}/integrations/*`,\n              arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n            },\n            stack,\n          ),\n        ],\n      }),\n    );\n    // PutConnectInstanceIntegration validates the four built-in campaign\n    // object-type TEMPLATES referenced by objectTypeNames (Campaign-Email,\n    // Campaign-SMS, Campaign-Telephony, Campaign-Orchestration) via\n    // profile:GetProfileObjectTypeTemplate, using the CALLER's credentials.\n    // Templates are account/region-level resources whose ARN carries a leading\n    // slash (`:/templates/<name>`), distinct from the domain, so they need their\n    // own grant.\n    const profileTemplatesArn = `arn:${stack.partition}:profile:${stack.region}:${stack.account}:/templates/*`;\n    associationFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          'profile:GetProfileObjectTypeTemplate',\n          'profile:ListProfileObjectTypeTemplates',\n        ],\n        resources: [profileTemplatesArn],\n      }),\n    );\n    // Onboarding auto-creates the Outbound Campaigns service-linked role; the\n    // handler then lists roles to resolve its ARN. iam:ListRoles has no\n    // resource-level scoping, so it must target `*`.\n    associationFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: ['iam:ListRoles'],\n        resources: ['*'],\n      }),\n    );\n    // Each StartInstanceOnboardingJob for a NEW Connect instance creates its own\n    // connect-campaigns service-linked role (the role name carries a\n    // service-generated random suffix), so the grant must use `*` for the\n    // resource and is instead scoped safely by the iam:AWSServiceName condition\n    // to ONLY the connect-campaigns SLR. A path-scoped resource ARN is denied by\n    // IAM here (surfaced as the onboarding job's IAM_ACCESS_DENIED failureCode).\n    const campaignsSlrArn = `arn:${stack.partition}:iam::${stack.account}:role/aws-service-role/${CONNECT_CAMPAIGNS_SERVICE_NAME}/*`;\n    associationFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: ['iam:CreateServiceLinkedRole'],\n        resources: ['*'],\n        conditions: {\n          StringEquals: {\n            'iam:AWSServiceName': CONNECT_CAMPAIGNS_SERVICE_NAME,\n          },\n        },\n      }),\n    );\n    associationFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: ['iam:PassRole'],\n        resources: [campaignsSlrArn],\n      }),\n    );\n    // During onboarding, connect-campaigns customizes its service-linked role\n    // with instance-specific inline permissions (the \"additional permissions\n    // added for the service-linked role to access the resources\", incl. the\n    // Customer Profiles integration access) via iam:PutRolePolicy /\n    // iam:AttachRolePolicy, performed with the CALLER's credentials. Without\n    // these the onboarding job fails with failureCode IAM_ACCESS_DENIED. The\n    // reverse (Delete/Detach) mirrors this so the best-effort teardown can\n    // remove those inline permissions when disassociating. Scoped to ONLY the\n    // connect-campaigns service-linked role.\n    associationFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          'iam:PutRolePolicy',\n          'iam:AttachRolePolicy',\n          'iam:DeleteRolePolicy',\n          'iam:DetachRolePolicy',\n        ],\n        resources: [campaignsSlrArn],\n      }),\n    );\n    // Onboarding also provisions a managed EventBridge rule (named\n    // `ConnectCampaignsRule*`) that drives campaign event delivery, created with\n    // the CALLER's credentials. Without these the onboarding job fails with\n    // failureCode EVENT_BRIDGE_ACCESS_DENIED. ListRules has no resource-level\n    // scoping; the mutating actions are scoped to the ConnectCampaignsRule* name.\n    const connectCampaignsRuleArn = `arn:${stack.partition}:events:${stack.region}:${stack.account}:rule/ConnectCampaignsRule*`;\n    associationFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: ['events:ListRules'],\n        resources: ['*'],\n      }),\n    );\n    associationFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          'events:PutRule',\n          'events:PutTargets',\n          'events:DeleteRule',\n          'events:RemoveTargets',\n          'events:ListTargetsByRule',\n          'events:DescribeRule',\n        ],\n        resources: [connectCampaignsRuleArn],\n      }),\n    );\n\n    const provider = new Provider(this, 'CampaignAssociationProvider', {\n      onEventHandler: associationFn,\n    });\n\n    const association = new CustomResource(this, 'CampaignAssociation', {\n      serviceToken: provider.serviceToken,\n      resourceType: 'Custom::OutboundCampaignsDomainAssociation',\n      properties: {\n        ConnectInstanceId: connectInstance.attrId,\n        DomainName: domainName,\n        Account: stack.account,\n        Region: stack.region,\n      },\n    });\n\n    // Provision after — and tear down before — the instance + domain it links.\n    association.node.addDependency(connectInstance);\n    association.node.addDependency(profilesDomain);\n  }\n\n  /**\n   * Deterministic, stable, per-app base name for the created Connect instance\n   * and Customer Profiles domain (create-from-scratch mode).\n   *\n   * The name must be STABLE across deploy and delete (so CFN resolves the same\n   * resource on teardown) and UNIQUE per app / environment (so two apps in the\n   * same account don't collide on the globally-unique Connect alias). It is\n   * derived from a short hash of the root stack name (which, in Amplify Gen2,\n   * embeds the app namespace + branch) plus this construct's path — both stable\n   * inputs.\n   *\n   * The `amazon-connect-` prefix is REQUIRED, not cosmetic: Amazon Connect's\n   * AWS-managed service-linked-role policy (`AmazonConnectServiceLinkedRolePolicy`,\n   * statement `AllowCustomerProfilesForConnectDomain`) grants the instance's\n   * role `profile:*` ONLY on `arn:aws:profile:*:*:domains/amazon-connect-*`. A\n   * domain named otherwise is unreachable by the instance — the Connect console\n   * and Journey segment builder then report \"does not have permissions to access\n   * Customer Profiles\". The SLR is AWS-protected (no inline policy can be added)\n   * and the managed policy is not editable, so the domain name is the only lever.\n   */\n  private generateResourceName(): string {\n    let root: Stack = this.stack;\n    while (root.nestedStackParent) {\n      root = root.nestedStackParent;\n    }\n    const seed = `${root.stackName}::${this.node.path}`;\n    const suffix = createHash('sha256').update(seed).digest('hex').slice(0, 12);\n    return `amazon-connect-notifications-${suffix}`;\n  }\n\n  /**\n   * Coerce an arbitrary string into a valid Amazon Connect instance alias:\n   * lowercase alphanumeric characters + single hyphens, no leading/trailing hyphen, not\n   * starting with the reserved `d-` prefix, and within Connect's 1–62 char\n   * bound.\n   */\n  private sanitizeInstanceAlias(raw: string): string {\n    let alias = raw\n      .toLowerCase()\n      .replace(/[^a-z0-9-]/g, '-')\n      .replace(/-+/g, '-')\n      .replace(/^-+|-+$/g, '');\n    if (alias.startsWith('d-')) {\n      alias = `a${alias}`;\n    }\n    if (alias.length === 0) {\n      alias = 'amplify-notifications';\n    }\n    return alias.slice(0, 62).replace(/-+$/g, '');\n  }\n}\n"]}