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

package/lib/lambda/push/message_template.js

@@ -0,0 +1,270 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { DescribeCampaignCommand, } from '@aws-sdk/client-connectcampaignsv2';
+import { ListIntegrationAssociationsCommand, } from '@aws-sdk/client-connect';
+import { GetMessageTemplateCommand, ListMessageTemplatesCommand, RenderMessageTemplateCommand, } from '@aws-sdk/client-qconnect';
+import { ACTIVE_VERSION_QUALIFIER, PUSH_CHANNEL_SUBTYPE, Q_MESSAGE_TEMPLATES_INTEGRATION_TYPE, } from '../../constants.js';
+/** Max length of a single Q Connect render attribute value. */
+const MAX_ATTRIBUTE_LENGTH = 32767;
+/**
+ * Per-container cache of `campaignId -> knowledgeBaseId`. KB discovery
+ * (DescribeCampaign + ListIntegrationAssociations) is stable for a campaign's
+ * lifetime, so warm Lambda invocations skip the two lookups.
+ *
+ * TODO(prod): unbounded (one entry per distinct campaignId per container) — cap
+ * or TTL this before GA if a single container fronts many campaigns.
+ */
+const kbIdByCampaign = new Map();
+/**
+ * Discover the Q in Connect knowledge base backing a campaign's Connect
+ * instance, caching per container:
+ *
+ *   CampaignId -> connectcampaignsv2 DescribeCampaign -> campaign.connectInstanceId
+ *              -> connect ListIntegrationAssociations(Q_MESSAGE_TEMPLATES)
+ *              -> IntegrationArn (arn:aws:wisdom:...:knowledge-base/<kbId>) -> kbId
+ *
+ * Returns `undefined` (never throws) when the instance id or the KB integration
+ * cannot be resolved — the caller then falls back to non-templated copy. If
+ * DescribeCampaign does not carry `connectInstanceId`, that is logged so the
+ * real shape can be inspected.
+ */
+export const discoverKnowledgeBaseId = async (clients, campaignId) => {
+    const cached = kbIdByCampaign.get(campaignId);
+    if (cached) {
+        return cached;
+    }
+    const describe = await clients.campaigns.send(new DescribeCampaignCommand({ id: campaignId }));
+    const instanceId = describe.campaign?.connectInstanceId;
+    if (!instanceId) {
+        console.warn('[push] kb.discover.noInstanceId', JSON.stringify({
+            campaignId,
+            campaignKeys: Object.keys(describe.campaign ?? {}),
+        }));
+        return undefined;
+    }
+    const assoc = await clients.connect.send(new ListIntegrationAssociationsCommand({
+        InstanceId: instanceId,
+        IntegrationType: Q_MESSAGE_TEMPLATES_INTEGRATION_TYPE,
+    }));
+    // A Connect instance has at most one Q_MESSAGE_TEMPLATES binding, so page 1
+    // always carries it and we don't paginate. Surface a NextToken if that ever
+    // stops holding so the edge case is observable rather than a silent miss.
+    if (assoc.NextToken) {
+        console.warn('[push] kb.discover.multiplePages', JSON.stringify({ campaignId, instanceId }));
+    }
+    const integrationArn = assoc.IntegrationAssociationSummaryList?.find((a) => a.IntegrationArn)?.IntegrationArn;
+    // Only trust a well-formed Q in Connect knowledge-base ARN
+    // (arn:aws:wisdom:...:knowledge-base/<kbId>); anything else yields a garbage
+    // id that would fail three calls later at render time.
+    const kbId = integrationArn?.includes('knowledge-base/')
+        ? integrationArn.split('/').pop()
+        : undefined;
+    if (!kbId) {
+        console.warn('[push] kb.discover.noKnowledgeBase', JSON.stringify({ campaignId, instanceId, integrationArn }));
+        return undefined;
+    }
+    console.log('[push] kb.discover', JSON.stringify({ campaignId, instanceId, knowledgeBaseId: kbId }));
+    kbIdByCampaign.set(campaignId, kbId);
+    return kbId;
+};
+/**
+ * Find the PUSH message template in `knowledgeBaseId` whose name equals the
+ * journey `actionId` (the Custom-action block name). Pages ListMessageTemplates
+ * and filters client-side to `channelSubtype === PUSH`. Returns the matching
+ * template id, or `undefined` when none matches.
+ */
+const findPushTemplateId = async (qconnect, knowledgeBaseId, actionId) => {
+    let nextToken;
+    do {
+        const res = await qconnect.send(new ListMessageTemplatesCommand({
+            knowledgeBaseId,
+            maxResults: 100,
+            nextToken,
+        }));
+        const match = res.messageTemplateSummaries?.find((s) => s.channelSubtype === PUSH_CHANNEL_SUBTYPE && s.name === actionId);
+        if (match?.messageTemplateId) {
+            return match.messageTemplateId;
+        }
+        nextToken = res.nextToken;
+    } while (nextToken);
+    return undefined;
+};
+/**
+ * Resolve the PUSH message template for a journey run: discover the knowledge
+ * base from the campaign, find the PUSH template whose name == the ActionId,
+ * and confirm it has an ACTIVE version. Returns `undefined` (never throws) when
+ * anything is missing — no campaign metadata, no KB integration, no matching
+ * template — so the caller falls back to the non-templated per-profile copy.
+ */
+export const resolvePushTemplateContext = async (clients, campaign) => {
+    const campaignId = campaign.campaignId;
+    const actionId = campaign.actionId;
+    if (!campaignId || !actionId) {
+        console.log('[push] template.skip', JSON.stringify({
+            reason: 'missing campaignId or actionId',
+            campaignId: campaignId ?? null,
+            actionId: actionId ?? null,
+        }));
+        return undefined;
+    }
+    try {
+        const knowledgeBaseId = await discoverKnowledgeBaseId(clients, campaignId);
+        if (!knowledgeBaseId) {
+            return undefined;
+        }
+        const messageTemplateId = await findPushTemplateId(clients.qconnect, knowledgeBaseId, actionId);
+        if (!messageTemplateId) {
+            console.warn('[push] template.noMatch', JSON.stringify({ knowledgeBaseId, actionId }));
+            return undefined;
+        }
+        // Confirm an ACTIVE (published) version exists; if not, still render the
+        // latest content (GetMessageTemplate is diagnostic here, not a gate).
+        try {
+            await clients.qconnect.send(new GetMessageTemplateCommand({
+                knowledgeBaseId,
+                messageTemplateId: `${messageTemplateId}:${ACTIVE_VERSION_QUALIFIER}`,
+            }));
+        }
+        catch (err) {
+            console.warn('[push] template.noActiveVersion', JSON.stringify({
+                knowledgeBaseId,
+                messageTemplateId,
+                error: err instanceof Error ? err.message : 'unknown',
+            }));
+        }
+        console.log('[push] template.resolved', JSON.stringify({ knowledgeBaseId, messageTemplateId, actionId }));
+        return {
+            qconnect: clients.qconnect,
+            knowledgeBaseId,
+            messageTemplateId,
+            templateName: actionId,
+        };
+    }
+    catch (err) {
+        console.warn('[push] template.resolveError', JSON.stringify({
+            campaignId,
+            actionId,
+            error: err instanceof Error ? err.message : 'unknown',
+        }));
+        return undefined;
+    }
+};
+/**
+ * Flatten a profile's `CustomerData` into a flat `customAttributes` map for
+ * RenderMessageTemplate. Empirically only `{{Attributes.<flatKey>}}` variables
+ * interpolate (from `customAttributes`); the `{{Customer.*}}` namespace does not
+ * resolve here — so the profile's `firstName` and every `attributes.*` entry are
+ * passed as flat custom attributes (templates reference e.g.
+ * `{{Attributes.firstName}}`). Nested objects (`address`, `attributes`) are not
+ * added directly; `attributes` is merged one level deep. Non-string / empty
+ * values are dropped and values are capped at the render attribute-length limit.
+ */
+export const buildCustomAttributes = (customerData) => {
+    const out = {};
+    if (!customerData) {
+        return out;
+    }
+    const add = (key, value) => {
+        if (typeof value === 'string' && value.length > 0) {
+            out[key] = value.slice(0, MAX_ATTRIBUTE_LENGTH);
+        }
+    };
+    for (const [key, value] of Object.entries(customerData)) {
+        if (key === 'attributes' || key === 'address') {
+            continue;
+        }
+        add(key, value);
+    }
+    const attributes = customerData.attributes;
+    if (attributes &&
+        typeof attributes === 'object' &&
+        !Array.isArray(attributes)) {
+        // attributes sub-keys overwrite top-level keys on collision (attributes is
+        // the authoritative custom-attribute store).
+        for (const [key, value] of Object.entries(attributes)) {
+            add(key, value);
+        }
+    }
+    return out;
+};
+/**
+ * Detects a Handlebars placeholder the renderer left unresolved, e.g. a
+ * `{{Attributes.firstName}}` var for a profile that has no `firstName`. Q Connect
+ * leaves such vars LITERAL in the output (and lists them in
+ * `attributesNotInterpolated`); shipping that raw text to a device is a bug, so
+ * copy that still contains one is rejected and the caller falls back to default.
+ */
+const hasUnresolvedPlaceholder = (value) => /\{\{.*?\}\}/.test(value);
+const toMessage = (content) => {
+    const title = content?.title;
+    const body = content?.body?.content;
+    if (typeof title === 'string' &&
+        title.length > 0 &&
+        typeof body === 'string' &&
+        body.length > 0 &&
+        !hasUnresolvedPlaceholder(title) &&
+        !hasUnresolvedPlaceholder(body)) {
+        return { title, body };
+    }
+    return undefined;
+};
+/**
+ * Render the resolved PUSH template for ONE profile and map the per-platform
+ * copy to push channels:
+ *   - `push.apns` -> `APNS` (+ `APNS_SANDBOX`)
+ *   - `push.fcm`  -> `GCM`
+ *
+ * The profile's `CustomerData` is passed as flat `customAttributes` so
+ * `{{Attributes.<key>}}` variables personalize. Returns a partial per-channel
+ * map (only channels the template defines both a title and body for), or
+ * `undefined` (never throws) when there is no push content or the render fails —
+ * the caller then falls back to the non-templated copy for that profile.
+ */
+export const renderProfileChannelMessages = async (ctx, target) => {
+    const customAttributes = buildCustomAttributes(target.customerData);
+    let res;
+    try {
+        res = await ctx.qconnect.send(new RenderMessageTemplateCommand({
+            knowledgeBaseId: ctx.knowledgeBaseId,
+            // Render the PUBLISHED version explicitly (verified: RenderMessageTemplate
+            // accepts the `:$ACTIVE_VERSION` qualifier) so a later saved draft can't
+            // silently change production copy.
+            messageTemplateId: `${ctx.messageTemplateId}:${ACTIVE_VERSION_QUALIFIER}`,
+            attributes: { customAttributes },
+        }));
+    }
+    catch (err) {
+        console.warn('[push] template.renderError', JSON.stringify({
+            templateName: ctx.templateName,
+            error: err instanceof Error ? err.message : 'unknown',
+        }));
+        return undefined;
+    }
+    const content = res.content;
+    const push = content?.push;
+    if (!push) {
+        return undefined;
+    }
+    const apns = toMessage(push.apns);
+    const fcm = toMessage(push.fcm);
+    const perChannel = {};
+    if (apns) {
+        perChannel.APNS = apns;
+        perChannel.APNS_SANDBOX = apns;
+    }
+    if (fcm) {
+        perChannel.GCM = fcm;
+    }
+    // Operational signal only: which channels the template rendered usable copy
+    // for, plus any template variables the renderer left un-interpolated (these
+    // are template-author-defined variable names, e.g. `Attributes.firstName`,
+    // not customer values). The rendered title/body are never logged.
+    console.log('[push] template.render', JSON.stringify({
+        templateName: ctx.templateName,
+        apnsRendered: Boolean(apns),
+        gcmRendered: Boolean(fcm),
+        attributesNotInterpolated: res.attributesNotInterpolated ?? [],
+    }));
+    return Object.keys(perChannel).length > 0 ? perChannel : undefined;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message_template.js","sourceRoot":"","sources":["../../../src/lambda/push/message_template.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  ConnectCampaignsV2Client,\n  DescribeCampaignCommand,\n} from '@aws-sdk/client-connectcampaignsv2';\nimport {\n  ConnectClient,\n  ListIntegrationAssociationsCommand,\n} from '@aws-sdk/client-connect';\nimport {\n  GetMessageTemplateCommand,\n  ListMessageTemplatesCommand,\n  QConnectClient,\n  RenderMessageTemplateCommand,\n} from '@aws-sdk/client-qconnect';\n\nimport {\n  ACTIVE_VERSION_QUALIFIER,\n  PUSH_CHANNEL_SUBTYPE,\n  Q_MESSAGE_TEMPLATES_INTEGRATION_TYPE,\n} from '../../constants.js';\nimport {\n  CampaignContext,\n  ProfileTarget,\n  PushChannelType,\n  PushMessage,\n} from './types.js';\n\n/** Max length of a single Q Connect render attribute value. */\nconst MAX_ATTRIBUTE_LENGTH = 32767;\n\n/** The AWS clients the template resolver needs. */\nexport type TemplateClients = {\n  campaigns: ConnectCampaignsV2Client;\n  connect: ConnectClient;\n  qconnect: QConnectClient;\n};\n\n/**\n * A resolved Q in Connect PUSH message template for one journey run: the\n * knowledge base + the specific template id to render per profile. Produced by\n * {@link resolvePushTemplateContext} and carried on the delivery deps so\n * {@link renderProfileChannelMessages} can render personalized copy per profile.\n */\nexport type PushTemplateContext = {\n  qconnect: QConnectClient;\n  /** The discovered Q in Connect knowledge base id. */\n  knowledgeBaseId: string;\n  /** The PUSH message template id whose name matched the journey ActionId. */\n  messageTemplateId: string;\n  /** The template name (== the Custom-action block name / ActionId). */\n  templateName: string;\n};\n\n/**\n * Per-container cache of `campaignId -> knowledgeBaseId`. KB discovery\n * (DescribeCampaign + ListIntegrationAssociations) is stable for a campaign's\n * lifetime, so warm Lambda invocations skip the two lookups.\n *\n * TODO(prod): unbounded (one entry per distinct campaignId per container) — cap\n * or TTL this before GA if a single container fronts many campaigns.\n */\nconst kbIdByCampaign = new Map<string, string>();\n\n/** The shape we read out of a Q Connect PUSH template platform entry. */\ntype PlatformContent = {\n  title?: string;\n  body?: { content?: string };\n};\n\n/**\n * Discover the Q in Connect knowledge base backing a campaign's Connect\n * instance, caching per container:\n *\n *   CampaignId -> connectcampaignsv2 DescribeCampaign -> campaign.connectInstanceId\n *              -> connect ListIntegrationAssociations(Q_MESSAGE_TEMPLATES)\n *              -> IntegrationArn (arn:aws:wisdom:...:knowledge-base/<kbId>) -> kbId\n *\n * Returns `undefined` (never throws) when the instance id or the KB integration\n * cannot be resolved — the caller then falls back to non-templated copy. If\n * DescribeCampaign does not carry `connectInstanceId`, that is logged so the\n * real shape can be inspected.\n */\nexport const discoverKnowledgeBaseId = async (\n  clients: Pick<TemplateClients, 'campaigns' | 'connect'>,\n  campaignId: string,\n): Promise<string | undefined> => {\n  const cached = kbIdByCampaign.get(campaignId);\n  if (cached) {\n    return cached;\n  }\n\n  const describe = await clients.campaigns.send(\n    new DescribeCampaignCommand({ id: campaignId }),\n  );\n  const instanceId = describe.campaign?.connectInstanceId;\n  if (!instanceId) {\n    console.warn(\n      '[push] kb.discover.noInstanceId',\n      JSON.stringify({\n        campaignId,\n        campaignKeys: Object.keys(describe.campaign ?? {}),\n      }),\n    );\n    return undefined;\n  }\n\n  const assoc = await clients.connect.send(\n    new ListIntegrationAssociationsCommand({\n      InstanceId: instanceId,\n      IntegrationType: Q_MESSAGE_TEMPLATES_INTEGRATION_TYPE,\n    }),\n  );\n  // A Connect instance has at most one Q_MESSAGE_TEMPLATES binding, so page 1\n  // always carries it and we don't paginate. Surface a NextToken if that ever\n  // stops holding so the edge case is observable rather than a silent miss.\n  if (assoc.NextToken) {\n    console.warn(\n      '[push] kb.discover.multiplePages',\n      JSON.stringify({ campaignId, instanceId }),\n    );\n  }\n  const integrationArn = assoc.IntegrationAssociationSummaryList?.find(\n    (a) => a.IntegrationArn,\n  )?.IntegrationArn;\n  // Only trust a well-formed Q in Connect knowledge-base ARN\n  // (arn:aws:wisdom:...:knowledge-base/<kbId>); anything else yields a garbage\n  // id that would fail three calls later at render time.\n  const kbId = integrationArn?.includes('knowledge-base/')\n    ? integrationArn.split('/').pop()\n    : undefined;\n\n  if (!kbId) {\n    console.warn(\n      '[push] kb.discover.noKnowledgeBase',\n      JSON.stringify({ campaignId, instanceId, integrationArn }),\n    );\n    return undefined;\n  }\n\n  console.log(\n    '[push] kb.discover',\n    JSON.stringify({ campaignId, instanceId, knowledgeBaseId: kbId }),\n  );\n  kbIdByCampaign.set(campaignId, kbId);\n  return kbId;\n};\n\n/**\n * Find the PUSH message template in `knowledgeBaseId` whose name equals the\n * journey `actionId` (the Custom-action block name). Pages ListMessageTemplates\n * and filters client-side to `channelSubtype === PUSH`. Returns the matching\n * template id, or `undefined` when none matches.\n */\nconst findPushTemplateId = async (\n  qconnect: QConnectClient,\n  knowledgeBaseId: string,\n  actionId: string,\n): Promise<string | undefined> => {\n  let nextToken: string | undefined;\n  do {\n    const res = await qconnect.send(\n      new ListMessageTemplatesCommand({\n        knowledgeBaseId,\n        maxResults: 100,\n        nextToken,\n      }),\n    );\n    const match = res.messageTemplateSummaries?.find(\n      (s) => s.channelSubtype === PUSH_CHANNEL_SUBTYPE && s.name === actionId,\n    );\n    if (match?.messageTemplateId) {\n      return match.messageTemplateId;\n    }\n    nextToken = res.nextToken;\n  } while (nextToken);\n  return undefined;\n};\n\n/**\n * Resolve the PUSH message template for a journey run: discover the knowledge\n * base from the campaign, find the PUSH template whose name == the ActionId,\n * and confirm it has an ACTIVE version. Returns `undefined` (never throws) when\n * anything is missing — no campaign metadata, no KB integration, no matching\n * template — so the caller falls back to the non-templated per-profile copy.\n */\nexport const resolvePushTemplateContext = async (\n  clients: TemplateClients,\n  campaign: CampaignContext,\n): Promise<PushTemplateContext | undefined> => {\n  const campaignId = campaign.campaignId;\n  const actionId = campaign.actionId;\n  if (!campaignId || !actionId) {\n    console.log(\n      '[push] template.skip',\n      JSON.stringify({\n        reason: 'missing campaignId or actionId',\n        campaignId: campaignId ?? null,\n        actionId: actionId ?? null,\n      }),\n    );\n    return undefined;\n  }\n\n  try {\n    const knowledgeBaseId = await discoverKnowledgeBaseId(clients, campaignId);\n    if (!knowledgeBaseId) {\n      return undefined;\n    }\n\n    const messageTemplateId = await findPushTemplateId(\n      clients.qconnect,\n      knowledgeBaseId,\n      actionId,\n    );\n    if (!messageTemplateId) {\n      console.warn(\n        '[push] template.noMatch',\n        JSON.stringify({ knowledgeBaseId, actionId }),\n      );\n      return undefined;\n    }\n\n    // Confirm an ACTIVE (published) version exists; if not, still render the\n    // latest content (GetMessageTemplate is diagnostic here, not a gate).\n    try {\n      await clients.qconnect.send(\n        new GetMessageTemplateCommand({\n          knowledgeBaseId,\n          messageTemplateId: `${messageTemplateId}:${ACTIVE_VERSION_QUALIFIER}`,\n        }),\n      );\n    } catch (err) {\n      console.warn(\n        '[push] template.noActiveVersion',\n        JSON.stringify({\n          knowledgeBaseId,\n          messageTemplateId,\n          error: err instanceof Error ? err.message : 'unknown',\n        }),\n      );\n    }\n\n    console.log(\n      '[push] template.resolved',\n      JSON.stringify({ knowledgeBaseId, messageTemplateId, actionId }),\n    );\n    return {\n      qconnect: clients.qconnect,\n      knowledgeBaseId,\n      messageTemplateId,\n      templateName: actionId,\n    };\n  } catch (err) {\n    console.warn(\n      '[push] template.resolveError',\n      JSON.stringify({\n        campaignId,\n        actionId,\n        error: err instanceof Error ? err.message : 'unknown',\n      }),\n    );\n    return undefined;\n  }\n};\n\n/**\n * Flatten a profile's `CustomerData` into a flat `customAttributes` map for\n * RenderMessageTemplate. Empirically only `{{Attributes.<flatKey>}}` variables\n * interpolate (from `customAttributes`); the `{{Customer.*}}` namespace does not\n * resolve here — so the profile's `firstName` and every `attributes.*` entry are\n * passed as flat custom attributes (templates reference e.g.\n * `{{Attributes.firstName}}`). Nested objects (`address`, `attributes`) are not\n * added directly; `attributes` is merged one level deep. Non-string / empty\n * values are dropped and values are capped at the render attribute-length limit.\n */\nexport const buildCustomAttributes = (\n  customerData?: Record<string, unknown>,\n): Record<string, string> => {\n  const out: Record<string, string> = {};\n  if (!customerData) {\n    return out;\n  }\n  const add = (key: string, value: unknown): void => {\n    if (typeof value === 'string' && value.length > 0) {\n      out[key] = value.slice(0, MAX_ATTRIBUTE_LENGTH);\n    }\n  };\n  for (const [key, value] of Object.entries(customerData)) {\n    if (key === 'attributes' || key === 'address') {\n      continue;\n    }\n    add(key, value);\n  }\n  const attributes = customerData.attributes;\n  if (\n    attributes &&\n    typeof attributes === 'object' &&\n    !Array.isArray(attributes)\n  ) {\n    // attributes sub-keys overwrite top-level keys on collision (attributes is\n    // the authoritative custom-attribute store).\n    for (const [key, value] of Object.entries(\n      attributes as Record<string, unknown>,\n    )) {\n      add(key, value);\n    }\n  }\n  return out;\n};\n\n/**\n * Detects a Handlebars placeholder the renderer left unresolved, e.g. a\n * `{{Attributes.firstName}}` var for a profile that has no `firstName`. Q Connect\n * leaves such vars LITERAL in the output (and lists them in\n * `attributesNotInterpolated`); shipping that raw text to a device is a bug, so\n * copy that still contains one is rejected and the caller falls back to default.\n */\nconst hasUnresolvedPlaceholder = (value: string): boolean =>\n  /\\{\\{.*?\\}\\}/.test(value);\n\nconst toMessage = (content?: PlatformContent): PushMessage | undefined => {\n  const title = content?.title;\n  const body = content?.body?.content;\n  if (\n    typeof title === 'string' &&\n    title.length > 0 &&\n    typeof body === 'string' &&\n    body.length > 0 &&\n    !hasUnresolvedPlaceholder(title) &&\n    !hasUnresolvedPlaceholder(body)\n  ) {\n    return { title, body };\n  }\n  return undefined;\n};\n\n/**\n * Render the resolved PUSH template for ONE profile and map the per-platform\n * copy to push channels:\n *   - `push.apns` -> `APNS` (+ `APNS_SANDBOX`)\n *   - `push.fcm`  -> `GCM`\n *\n * The profile's `CustomerData` is passed as flat `customAttributes` so\n * `{{Attributes.<key>}}` variables personalize. Returns a partial per-channel\n * map (only channels the template defines both a title and body for), or\n * `undefined` (never throws) when there is no push content or the render fails —\n * the caller then falls back to the non-templated copy for that profile.\n */\nexport const renderProfileChannelMessages = async (\n  ctx: PushTemplateContext,\n  target: ProfileTarget,\n): Promise<Partial<Record<PushChannelType, PushMessage>> | undefined> => {\n  const customAttributes = buildCustomAttributes(target.customerData);\n\n  let res;\n  try {\n    res = await ctx.qconnect.send(\n      new RenderMessageTemplateCommand({\n        knowledgeBaseId: ctx.knowledgeBaseId,\n        // Render the PUBLISHED version explicitly (verified: RenderMessageTemplate\n        // accepts the `:$ACTIVE_VERSION` qualifier) so a later saved draft can't\n        // silently change production copy.\n        messageTemplateId: `${ctx.messageTemplateId}:${ACTIVE_VERSION_QUALIFIER}`,\n        attributes: { customAttributes },\n      }),\n    );\n  } catch (err) {\n    console.warn(\n      '[push] template.renderError',\n      JSON.stringify({\n        templateName: ctx.templateName,\n        error: err instanceof Error ? err.message : 'unknown',\n      }),\n    );\n    return undefined;\n  }\n\n  const content = res.content as\n    | { push?: { apns?: PlatformContent; fcm?: PlatformContent } }\n    | undefined;\n  const push = content?.push;\n  if (!push) {\n    return undefined;\n  }\n\n  const apns = toMessage(push.apns);\n  const fcm = toMessage(push.fcm);\n  const perChannel: Partial<Record<PushChannelType, PushMessage>> = {};\n  if (apns) {\n    perChannel.APNS = apns;\n    perChannel.APNS_SANDBOX = apns;\n  }\n  if (fcm) {\n    perChannel.GCM = fcm;\n  }\n\n  // Operational signal only: which channels the template rendered usable copy\n  // for, plus any template variables the renderer left un-interpolated (these\n  // are template-author-defined variable names, e.g. `Attributes.firstName`,\n  // not customer values). The rendered title/body are never logged.\n  console.log(\n    '[push] template.render',\n    JSON.stringify({\n      templateName: ctx.templateName,\n      apnsRendered: Boolean(apns),\n      gcmRendered: Boolean(fcm),\n      attributesNotInterpolated: res.attributesNotInterpolated ?? [],\n    }),\n  );\n\n  return Object.keys(perChannel).length > 0 ? perChannel : undefined;\n};\n"]}

package/lib/lambda/push/payload.d.ts

@@ -0,0 +1,25 @@
+import type { DirectMessageConfiguration } from '@aws-sdk/client-pinpoint';
+import { PushChannelType, PushMessage } from './types.js';
+/**
+ * Normalize a stored / event channel identifier to a Pinpoint push channel.
+ *
+ * The identify path stores whatever channel the client registered. Clients (and
+ * Firebase) use several spellings for Android push — `FCM` (the current Firebase
+ * Cloud Messaging name) is normalized to `GCM` (the Pinpoint channel that
+ * fronts FCM). Apple variants map to `APNS` / `APNS_SANDBOX`. Anything else
+ * (e.g. `IN_APP`, empty, unknown) yields `undefined` so the caller skips it.
+ */
+export declare const normalizeChannelType: (raw: string | undefined) => PushChannelType | undefined;
+/**
+ * Build the Pinpoint `DirectMessageConfiguration` for a single device, carrying
+ * only the platform message matching that device's channel.
+ *
+ * - `GCM` -> `GCMMessage` (Android / FCM)
+ * - `APNS` / `APNS_SANDBOX` -> `APNSMessage` (iOS)
+ *
+ * `title` / `body` map to the platform message's `Title` / `Body`; optional
+ * `data` maps to the platform `Data` map so the client receives the custom
+ * payload alongside the notification.
+ */
+export declare const buildMessageConfiguration: (channelType: PushChannelType, message: PushMessage) => DirectMessageConfiguration;
+//# sourceMappingURL=payload.d.ts.map

package/lib/lambda/push/payload.js

@@ -0,0 +1,53 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Normalize a stored / event channel identifier to a Pinpoint push channel.
+ *
+ * The identify path stores whatever channel the client registered. Clients (and
+ * Firebase) use several spellings for Android push — `FCM` (the current Firebase
+ * Cloud Messaging name) is normalized to `GCM` (the Pinpoint channel that
+ * fronts FCM). Apple variants map to `APNS` / `APNS_SANDBOX`. Anything else
+ * (e.g. `IN_APP`, empty, unknown) yields `undefined` so the caller skips it.
+ */
+export const normalizeChannelType = (raw) => {
+    if (!raw) {
+        return undefined;
+    }
+    switch (raw.trim().toUpperCase()) {
+        case 'FCM':
+        case 'GCM':
+            return 'GCM';
+        case 'APNS':
+            return 'APNS';
+        case 'APNS_SANDBOX':
+        case 'APNSSANDBOX':
+            return 'APNS_SANDBOX';
+        default:
+            return undefined;
+    }
+};
+/**
+ * Build the Pinpoint `DirectMessageConfiguration` for a single device, carrying
+ * only the platform message matching that device's channel.
+ *
+ * - `GCM` -> `GCMMessage` (Android / FCM)
+ * - `APNS` / `APNS_SANDBOX` -> `APNSMessage` (iOS)
+ *
+ * `title` / `body` map to the platform message's `Title` / `Body`; optional
+ * `data` maps to the platform `Data` map so the client receives the custom
+ * payload alongside the notification.
+ */
+export const buildMessageConfiguration = (channelType, message) => {
+    const common = {
+        Title: message.title,
+        Body: message.body,
+        ...(message.data ? { Data: message.data } : {}),
+    };
+    if (channelType === 'GCM') {
+        return { GCMMessage: { ...common, Priority: 'high' } };
+    }
+    // APNS and APNS_SANDBOX both use APNSMessage; the channel is selected per
+    // address via AddressConfiguration.ChannelType.
+    return { APNSMessage: common };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF5bG9hZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9sYW1iZGEvcHVzaC9wYXlsb2FkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHFFQUFxRTtBQUNyRSxzQ0FBc0M7QUFLdEM7Ozs7Ozs7O0dBUUc7QUFDSCxNQUFNLENBQUMsTUFBTSxvQkFBb0IsR0FBRyxDQUNsQyxHQUF1QixFQUNNLEVBQUU7SUFDL0IsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBQ1QsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztJQUNELFFBQVEsR0FBRyxDQUFDLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRSxFQUFFLENBQUM7UUFDakMsS0FBSyxLQUFLLENBQUM7UUFDWCxLQUFLLEtBQUs7WUFDUixPQUFPLEtBQUssQ0FBQztRQUNmLEtBQUssTUFBTTtZQUNULE9BQU8sTUFBTSxDQUFDO1FBQ2hCLEtBQUssY0FBYyxDQUFDO1FBQ3BCLEtBQUssYUFBYTtZQUNoQixPQUFPLGNBQWMsQ0FBQztRQUN4QjtZQUNFLE9BQU8sU0FBUyxDQUFDO0lBQ3JCLENBQUM7QUFDSCxDQUFDLENBQUM7QUFFRjs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQUcsQ0FDdkMsV0FBNEIsRUFDNUIsT0FBb0IsRUFDUSxFQUFFO0lBQzlCLE1BQU0sTUFBTSxHQUFHO1FBQ2IsS0FBSyxFQUFFLE9BQU8sQ0FBQyxLQUFLO1FBQ3BCLElBQUksRUFBRSxPQUFPLENBQUMsSUFBSTtRQUNsQixHQUFHLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7S0FDaEQsQ0FBQztJQUVGLElBQUksV0FBVyxLQUFLLEtBQUssRUFBRSxDQUFDO1FBQzFCLE9BQU8sRUFBRSxVQUFVLEVBQUUsRUFBRSxHQUFHLE1BQU0sRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLEVBQUUsQ0FBQztJQUN6RCxDQUFDO0lBQ0QsMEVBQTBFO0lBQzFFLGdEQUFnRDtJQUNoRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sRUFBRSxDQUFDO0FBQ2pDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCBBbWF6b24uY29tLCBJbmMuIG9yIGl0cyBhZmZpbGlhdGVzLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuaW1wb3J0IHR5cGUgeyBEaXJlY3RNZXNzYWdlQ29uZmlndXJhdGlvbiB9IGZyb20gJ0Bhd3Mtc2RrL2NsaWVudC1waW5wb2ludCc7XG5pbXBvcnQgeyBQdXNoQ2hhbm5lbFR5cGUsIFB1c2hNZXNzYWdlIH0gZnJvbSAnLi90eXBlcy5qcyc7XG5cbi8qKlxuICogTm9ybWFsaXplIGEgc3RvcmVkIC8gZXZlbnQgY2hhbm5lbCBpZGVudGlmaWVyIHRvIGEgUGlucG9pbnQgcHVzaCBjaGFubmVsLlxuICpcbiAqIFRoZSBpZGVudGlmeSBwYXRoIHN0b3JlcyB3aGF0ZXZlciBjaGFubmVsIHRoZSBjbGllbnQgcmVnaXN0ZXJlZC4gQ2xpZW50cyAoYW5kXG4gKiBGaXJlYmFzZSkgdXNlIHNldmVyYWwgc3BlbGxpbmdzIGZvciBBbmRyb2lkIHB1c2gg4oCUIGBGQ01gICh0aGUgY3VycmVudCBGaXJlYmFzZVxuICogQ2xvdWQgTWVzc2FnaW5nIG5hbWUpIGlzIG5vcm1hbGl6ZWQgdG8gYEdDTWAgKHRoZSBQaW5wb2ludCBjaGFubmVsIHRoYXRcbiAqIGZyb250cyBGQ00pLiBBcHBsZSB2YXJpYW50cyBtYXAgdG8gYEFQTlNgIC8gYEFQTlNfU0FOREJPWGAuIEFueXRoaW5nIGVsc2VcbiAqIChlLmcuIGBJTl9BUFBgLCBlbXB0eSwgdW5rbm93bikgeWllbGRzIGB1bmRlZmluZWRgIHNvIHRoZSBjYWxsZXIgc2tpcHMgaXQuXG4gKi9cbmV4cG9ydCBjb25zdCBub3JtYWxpemVDaGFubmVsVHlwZSA9IChcbiAgcmF3OiBzdHJpbmcgfCB1bmRlZmluZWQsXG4pOiBQdXNoQ2hhbm5lbFR5cGUgfCB1bmRlZmluZWQgPT4ge1xuICBpZiAoIXJhdykge1xuICAgIHJldHVybiB1bmRlZmluZWQ7XG4gIH1cbiAgc3dpdGNoIChyYXcudHJpbSgpLnRvVXBwZXJDYXNlKCkpIHtcbiAgICBjYXNlICdGQ00nOlxuICAgIGNhc2UgJ0dDTSc6XG4gICAgICByZXR1cm4gJ0dDTSc7XG4gICAgY2FzZSAnQVBOUyc6XG4gICAgICByZXR1cm4gJ0FQTlMnO1xuICAgIGNhc2UgJ0FQTlNfU0FOREJPWCc6XG4gICAgY2FzZSAnQVBOU1NBTkRCT1gnOlxuICAgICAgcmV0dXJuICdBUE5TX1NBTkRCT1gnO1xuICAgIGRlZmF1bHQ6XG4gICAgICByZXR1cm4gdW5kZWZpbmVkO1xuICB9XG59O1xuXG4vKipcbiAqIEJ1aWxkIHRoZSBQaW5wb2ludCBgRGlyZWN0TWVzc2FnZUNvbmZpZ3VyYXRpb25gIGZvciBhIHNpbmdsZSBkZXZpY2UsIGNhcnJ5aW5nXG4gKiBvbmx5IHRoZSBwbGF0Zm9ybSBtZXNzYWdlIG1hdGNoaW5nIHRoYXQgZGV2aWNlJ3MgY2hhbm5lbC5cbiAqXG4gKiAtIGBHQ01gIC0+IGBHQ01NZXNzYWdlYCAoQW5kcm9pZCAvIEZDTSlcbiAqIC0gYEFQTlNgIC8gYEFQTlNfU0FOREJPWGAgLT4gYEFQTlNNZXNzYWdlYCAoaU9TKVxuICpcbiAqIGB0aXRsZWAgLyBgYm9keWAgbWFwIHRvIHRoZSBwbGF0Zm9ybSBtZXNzYWdlJ3MgYFRpdGxlYCAvIGBCb2R5YDsgb3B0aW9uYWxcbiAqIGBkYXRhYCBtYXBzIHRvIHRoZSBwbGF0Zm9ybSBgRGF0YWAgbWFwIHNvIHRoZSBjbGllbnQgcmVjZWl2ZXMgdGhlIGN1c3RvbVxuICogcGF5bG9hZCBhbG9uZ3NpZGUgdGhlIG5vdGlmaWNhdGlvbi5cbiAqL1xuZXhwb3J0IGNvbnN0IGJ1aWxkTWVzc2FnZUNvbmZpZ3VyYXRpb24gPSAoXG4gIGNoYW5uZWxUeXBlOiBQdXNoQ2hhbm5lbFR5cGUsXG4gIG1lc3NhZ2U6IFB1c2hNZXNzYWdlLFxuKTogRGlyZWN0TWVzc2FnZUNvbmZpZ3VyYXRpb24gPT4ge1xuICBjb25zdCBjb21tb24gPSB7XG4gICAgVGl0bGU6IG1lc3NhZ2UudGl0bGUsXG4gICAgQm9keTogbWVzc2FnZS5ib2R5LFxuICAgIC4uLihtZXNzYWdlLmRhdGEgPyB7IERhdGE6IG1lc3NhZ2UuZGF0YSB9IDoge30pLFxuICB9O1xuXG4gIGlmIChjaGFubmVsVHlwZSA9PT0gJ0dDTScpIHtcbiAgICByZXR1cm4geyBHQ01NZXNzYWdlOiB7IC4uLmNvbW1vbiwgUHJpb3JpdHk6ICdoaWdoJyB9IH07XG4gIH1cbiAgLy8gQVBOUyBhbmQgQVBOU19TQU5EQk9YIGJvdGggdXNlIEFQTlNNZXNzYWdlOyB0aGUgY2hhbm5lbCBpcyBzZWxlY3RlZCBwZXJcbiAgLy8gYWRkcmVzcyB2aWEgQWRkcmVzc0NvbmZpZ3VyYXRpb24uQ2hhbm5lbFR5cGUuXG4gIHJldHVybiB7IEFQTlNNZXNzYWdlOiBjb21tb24gfTtcbn07XG4iXX0=

package/lib/lambda/push/types.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Frozen contract for the push-delivery Lambda.
+ *
+ * Amazon Connect has no native mobile-push channel. Delivery is a workaround:
+ * a Connect Journey Custom-action (Invoke Lambda) block calls THIS Lambda,
+ * which resolves each targeted profile's registered devices from Customer
+ * Profiles and pushes to them via AWS End User Messaging (the Pinpoint
+ * `SendMessages` API).
+ *
+ * These types mirror the JSON shapes the Lambda accepts / returns so the
+ * handler, the parsing / payload / delivery layers, and the tests share one
+ * source of truth.
+ */
+/** The push channels this backend can deliver to (post-normalization). */
+export type PushChannelType = 'GCM' | 'APNS' | 'APNS_SANDBOX';
+/** A single push notification's content. */
+export type PushMessage = {
+    /** Title shown above the notification. */
+    title: string;
+    /** Notification body text. */
+    body: string;
+    /**
+     * Optional opaque data payload delivered alongside the notification (added to
+     * the platform message's `Data` map, all values coerced to strings).
+     */
+    data?: Record<string, string>;
+};
+/**
+ * A single profile the Journey targeted, as surfaced to this Lambda. Mirrors a
+ * Connect Journey Custom-action `CustomerProfiles` entry: the resolved
+ * `ProfileId` plus a bag of profile fields / attributes (`CustomerData`).
+ */
+export type ProfileTarget = {
+    /** The Customer Profiles ProfileId to deliver to. */
+    profileId: string;
+    /**
+     * The profile's standard fields + Attributes as delivered by Connect
+     * (camelCase: `firstName`, `attributes.*`, ...). Passed as flat
+     * `customAttributes` to personalize the rendered Q Connect PUSH template (see
+     * `renderProfileChannelMessages`); real journeys carry NO message copy here.
+     * Device tokens are always resolved authoritatively via ListProfileObjects,
+     * never from here.
+     */
+    customerData?: Record<string, unknown>;
+};
+/**
+ * Which envelope shape {@link parsePushEvent} matched, for observability.
+ * `canonical` — the real Connect Outbound Campaigns v2 journey envelope
+ * (`Items.CustomerProfiles[]`); `none` — no targets were resolvable.
+ */
+export type PushEventParsePath = 'canonical' | 'none';
+/**
+ * The Outbound Campaigns v2 journey context carried on the real invocation
+ * envelope under `InvocationMetadata.CampaignContext`. Extracted for
+ * observability and for the upcoming message-copy-by-campaign feature (message
+ * sourcing is NOT implemented off this yet). All fields optional/defensive
+ * since direct-invoke test payloads omit them.
+ */
+export type CampaignContext = {
+    /** The Connect campaign / journey id. */
+    campaignId?: string;
+    /** The human-readable campaign / journey name (e.g. `journey-2`). */
+    campaignName?: string;
+    /** The journey action id (e.g. the Custom-action block name). */
+    actionId?: string;
+    /** The specific campaign run id for this invocation. */
+    runId?: string;
+};
+/** The normalized result of parsing a raw Journey Custom-action event. */
+export type ParsedPushEvent = {
+    /** Every profile the event targeted (batches are flattened). */
+    targets: ProfileTarget[];
+    /**
+     * The safe DEFAULT push copy ({@link DEFAULT_PUSH_TITLE} /
+     * {@link DEFAULT_PUSH_BODY}) used as the fallback when no Q Connect template
+     * copy applies for a channel. Real journeys carry no event-level copy.
+     */
+    message: PushMessage;
+    /**
+     * The envelope shape that produced the targets (`canonical`), or `none` when
+     * no targets were resolvable. Logged by the handler for observability.
+     */
+    parsePath: PushEventParsePath;
+    /**
+     * The journey/campaign context from `InvocationMetadata.CampaignContext`,
+     * when present on the envelope (real Outbound Campaigns v2 journeys), else
+     * `undefined` (direct-invoke test payloads).
+     */
+    campaign?: CampaignContext;
+};
+/** Delivery outcome for a single device (one `SendMessages` call). */
+export type DeviceDeliveryResult = {
+    /** The push token the message was addressed to. */
+    deviceToken: string;
+    /** The (normalized) channel the message was sent on. */
+    channelType: PushChannelType;
+    /**
+     * The Customer Profiles ProfileObjectUniqueKey of the AmplifyDevice object
+     * this token came from — carried so a stale token can be deleted.
+     */
+    objectUniqueKey?: string;
+    /**
+     * Pinpoint `DeliveryStatus` (`SUCCESSFUL`, `PERMANENT_FAILURE`, ...), or
+     * `ERROR` when the `SendMessages` call itself threw, or `SKIPPED` when the
+     * device could not be delivered to (e.g. unsupported / missing channel).
+     */
+    status: string;
+    /** Whether delivery succeeded. */
+    delivered: boolean;
+    /**
+     * Whether this represents a permanently-invalid TOKEN whose backing
+     * AmplifyDevice object should be deleted (stale-token cleanup). Set ONLY for
+     * a token-invalidity signal (see `isInvalidTokenFailure`); channel / app
+     * misconfiguration and transient failures are `false` (token kept).
+     */
+    stale: boolean;
+    /** Pinpoint numeric status code, when available. */
+    statusCode?: number;
+    /** Human-readable status / error detail. */
+    statusMessage?: string;
+};
+/** Aggregated delivery outcome for a single profile. */
+export type ProfileDeliveryResult = {
+    profileId: string;
+    /** Number of devices delivered to successfully. */
+    delivered: number;
+    /** Number of devices that failed delivery. */
+    failed: number;
+    /** Number of stale device objects deleted during cleanup. */
+    cleaned: number;
+    /** Per-device breakdown. */
+    devices: DeviceDeliveryResult[];
+};
+/**
+ * The response returned to the Connect Journey Custom-action invocation.
+ *
+ * NOTE: Connect's exact expected custom-action response envelope for the
+ * outbound-campaigns Journey batch is not publicly documented; this structured
+ * per-profile summary is a best-effort shape and is flagged for review.
+ */
+export type PushDeliveryResponse = {
+    /** Total profiles processed. */
+    profilesProcessed: number;
+    /** Total devices delivered to across all profiles. */
+    totalDelivered: number;
+    /** Total device deliveries that failed across all profiles. */
+    totalFailed: number;
+    /** Total stale device objects deleted across all profiles. */
+    totalCleaned: number;
+    /** Per-profile results. */
+    results: ProfileDeliveryResult[];
+};
+//# sourceMappingURL=types.d.ts.map

package/lib/lambda/push/types.js

@@ -0,0 +1,4 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/lambda/push/types.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,sCAAsC","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Frozen contract for the push-delivery Lambda.\n *\n * Amazon Connect has no native mobile-push channel. Delivery is a workaround:\n * a Connect Journey Custom-action (Invoke Lambda) block calls THIS Lambda,\n * which resolves each targeted profile's registered devices from Customer\n * Profiles and pushes to them via AWS End User Messaging (the Pinpoint\n * `SendMessages` API).\n *\n * These types mirror the JSON shapes the Lambda accepts / returns so the\n * handler, the parsing / payload / delivery layers, and the tests share one\n * source of truth.\n */\n\n/** The push channels this backend can deliver to (post-normalization). */\nexport type PushChannelType = 'GCM' | 'APNS' | 'APNS_SANDBOX';\n\n/** A single push notification's content. */\nexport type PushMessage = {\n  /** Title shown above the notification. */\n  title: string;\n  /** Notification body text. */\n  body: string;\n  /**\n   * Optional opaque data payload delivered alongside the notification (added to\n   * the platform message's `Data` map, all values coerced to strings).\n   */\n  data?: Record<string, string>;\n};\n\n/**\n * A single profile the Journey targeted, as surfaced to this Lambda. Mirrors a\n * Connect Journey Custom-action `CustomerProfiles` entry: the resolved\n * `ProfileId` plus a bag of profile fields / attributes (`CustomerData`).\n */\nexport type ProfileTarget = {\n  /** The Customer Profiles ProfileId to deliver to. */\n  profileId: string;\n  /**\n   * The profile's standard fields + Attributes as delivered by Connect\n   * (camelCase: `firstName`, `attributes.*`, ...). Passed as flat\n   * `customAttributes` to personalize the rendered Q Connect PUSH template (see\n   * `renderProfileChannelMessages`); real journeys carry NO message copy here.\n   * Device tokens are always resolved authoritatively via ListProfileObjects,\n   * never from here.\n   */\n  customerData?: Record<string, unknown>;\n};\n\n/**\n * Which envelope shape {@link parsePushEvent} matched, for observability.\n * `canonical` — the real Connect Outbound Campaigns v2 journey envelope\n * (`Items.CustomerProfiles[]`); `none` — no targets were resolvable.\n */\nexport type PushEventParsePath = 'canonical' | 'none';\n\n/**\n * The Outbound Campaigns v2 journey context carried on the real invocation\n * envelope under `InvocationMetadata.CampaignContext`. Extracted for\n * observability and for the upcoming message-copy-by-campaign feature (message\n * sourcing is NOT implemented off this yet). All fields optional/defensive\n * since direct-invoke test payloads omit them.\n */\nexport type CampaignContext = {\n  /** The Connect campaign / journey id. */\n  campaignId?: string;\n  /** The human-readable campaign / journey name (e.g. `journey-2`). */\n  campaignName?: string;\n  /** The journey action id (e.g. the Custom-action block name). */\n  actionId?: string;\n  /** The specific campaign run id for this invocation. */\n  runId?: string;\n};\n\n/** The normalized result of parsing a raw Journey Custom-action event. */\nexport type ParsedPushEvent = {\n  /** Every profile the event targeted (batches are flattened). */\n  targets: ProfileTarget[];\n  /**\n   * The safe DEFAULT push copy ({@link DEFAULT_PUSH_TITLE} /\n   * {@link DEFAULT_PUSH_BODY}) used as the fallback when no Q Connect template\n   * copy applies for a channel. Real journeys carry no event-level copy.\n   */\n  message: PushMessage;\n  /**\n   * The envelope shape that produced the targets (`canonical`), or `none` when\n   * no targets were resolvable. Logged by the handler for observability.\n   */\n  parsePath: PushEventParsePath;\n  /**\n   * The journey/campaign context from `InvocationMetadata.CampaignContext`,\n   * when present on the envelope (real Outbound Campaigns v2 journeys), else\n   * `undefined` (direct-invoke test payloads).\n   */\n  campaign?: CampaignContext;\n};\n\n/** Delivery outcome for a single device (one `SendMessages` call). */\nexport type DeviceDeliveryResult = {\n  /** The push token the message was addressed to. */\n  deviceToken: string;\n  /** The (normalized) channel the message was sent on. */\n  channelType: PushChannelType;\n  /**\n   * The Customer Profiles ProfileObjectUniqueKey of the AmplifyDevice object\n   * this token came from — carried so a stale token can be deleted.\n   */\n  objectUniqueKey?: string;\n  /**\n   * Pinpoint `DeliveryStatus` (`SUCCESSFUL`, `PERMANENT_FAILURE`, ...), or\n   * `ERROR` when the `SendMessages` call itself threw, or `SKIPPED` when the\n   * device could not be delivered to (e.g. unsupported / missing channel).\n   */\n  status: string;\n  /** Whether delivery succeeded. */\n  delivered: boolean;\n  /**\n   * Whether this represents a permanently-invalid TOKEN whose backing\n   * AmplifyDevice object should be deleted (stale-token cleanup). Set ONLY for\n   * a token-invalidity signal (see `isInvalidTokenFailure`); channel / app\n   * misconfiguration and transient failures are `false` (token kept).\n   */\n  stale: boolean;\n  /** Pinpoint numeric status code, when available. */\n  statusCode?: number;\n  /** Human-readable status / error detail. */\n  statusMessage?: string;\n};\n\n/** Aggregated delivery outcome for a single profile. */\nexport type ProfileDeliveryResult = {\n  profileId: string;\n  /** Number of devices delivered to successfully. */\n  delivered: number;\n  /** Number of devices that failed delivery. */\n  failed: number;\n  /** Number of stale device objects deleted during cleanup. */\n  cleaned: number;\n  /** Per-device breakdown. */\n  devices: DeviceDeliveryResult[];\n};\n\n/**\n * The response returned to the Connect Journey Custom-action invocation.\n *\n * NOTE: Connect's exact expected custom-action response envelope for the\n * outbound-campaigns Journey batch is not publicly documented; this structured\n * per-profile summary is a best-effort shape and is flagged for review.\n */\nexport type PushDeliveryResponse = {\n  /** Total profiles processed. */\n  profilesProcessed: number;\n  /** Total devices delivered to across all profiles. */\n  totalDelivered: number;\n  /** Total device deliveries that failed across all profiles. */\n  totalFailed: number;\n  /** Total stale device objects deleted across all profiles. */\n  totalCleaned: number;\n  /** Per-profile results. */\n  results: ProfileDeliveryResult[];\n};\n"]}

package/lib/lambda/shared/retry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Customer Profiles serializes writes to a single profile: concurrent
+ * UpdateProfile / PutProfileObject calls against the same profile fail with a
+ * `BadRequestException: Failed to update profile due to concurrent update
+ * in-progress.` This is a TRANSIENT, idempotent condition (the write is safe to
+ * repeat), so the correct handling is a short bounded retry with jittered
+ * backoff rather than surfacing a 5xx to the caller.
+ */
+export declare const isTransientConcurrentUpdate: (err: unknown) => boolean;
+/**
+ * Run `fn`, retrying on transient concurrent-update / throttling errors with
+ * exponential backoff + full jitter. Non-transient errors propagate immediately.
+ */
+export declare const withTransientRetry: <T>(fn: () => Promise<T>, opts?: {
+    attempts?: number;
+    baseDelayMs?: number;
+}) => Promise<T>;
+//# sourceMappingURL=retry.d.ts.map