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

package/lib/lambda/identify/validation.js

@@ -0,0 +1,99 @@
+const CHANNEL_TYPES = [
+    'GCM',
+    'APNS',
+    'APNS_SANDBOX',
+    'IN_APP',
+];
+const OPT_OUTS = ['ALL', 'NONE'];
+const isPlainObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const isStringArray = (v) => Array.isArray(v) && v.every((x) => typeof x === 'string');
+const isStringMap = (v) => isPlainObject(v) && Object.values(v).every((x) => isStringArray(x));
+/**
+ * Validate the frozen identify-user request contract.
+ *
+ * Returns `{ ok: false, error }` on the first violation so the handler can map
+ * it to a 400. Identity is NOT validated here — the verified `sub` is supplied
+ * separately by the authorizer.
+ */
+export const validateBody = (body) => {
+    if (!isPlainObject(body)) {
+        return { ok: false, error: 'Request body must be a JSON object' };
+    }
+    if (body.userId !== undefined && typeof body.userId !== 'string') {
+        return { ok: false, error: 'userId must be a string when present' };
+    }
+    const userProfile = body.userProfile;
+    if (!isPlainObject(userProfile)) {
+        return {
+            ok: false,
+            error: 'userProfile is required and must be an object',
+        };
+    }
+    for (const key of ['name', 'email', 'plan']) {
+        if (userProfile[key] !== undefined &&
+            typeof userProfile[key] !== 'string') {
+            return { ok: false, error: `userProfile.${key} must be a string` };
+        }
+    }
+    if (userProfile.customProperties !== undefined &&
+        !isStringMap(userProfile.customProperties)) {
+        return {
+            ok: false,
+            error: 'userProfile.customProperties must be a map of string arrays',
+        };
+    }
+    if (userProfile.metrics !== undefined) {
+        if (!isPlainObject(userProfile.metrics) ||
+            !Object.values(userProfile.metrics).every((n) => typeof n === 'number')) {
+            return {
+                ok: false,
+                error: 'userProfile.metrics must be a map of numbers',
+            };
+        }
+    }
+    const options = body.options;
+    if (options !== undefined) {
+        if (!isPlainObject(options)) {
+            return { ok: false, error: 'options must be an object when present' };
+        }
+        if (options.address !== undefined && typeof options.address !== 'string') {
+            return { ok: false, error: 'options.address must be a string' };
+        }
+        if (options.deviceId !== undefined &&
+            typeof options.deviceId !== 'string') {
+            return { ok: false, error: 'options.deviceId must be a string' };
+        }
+        if (options.previousGuestIdentityId !== undefined &&
+            (typeof options.previousGuestIdentityId !== 'string' ||
+                options.previousGuestIdentityId.trim().length === 0 ||
+                options.previousGuestIdentityId.length > 128)) {
+            return {
+                ok: false,
+                error: 'options.previousGuestIdentityId must be a non-empty string',
+            };
+        }
+        if (options.channelType !== undefined &&
+            !CHANNEL_TYPES.includes(options.channelType)) {
+            return {
+                ok: false,
+                error: `options.channelType must be one of ${CHANNEL_TYPES.join(', ')}`,
+            };
+        }
+        if (options.optOut !== undefined &&
+            !OPT_OUTS.includes(options.optOut)) {
+            return {
+                ok: false,
+                error: `options.optOut must be one of ${OPT_OUTS.join(', ')}`,
+            };
+        }
+        if (options.userAttributes !== undefined &&
+            !isStringMap(options.userAttributes)) {
+            return {
+                ok: false,
+                error: 'options.userAttributes must be a map of string arrays',
+            };
+        }
+    }
+    return { ok: true, value: body };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validation.js","sourceRoot":"","sources":["../../../src/lambda/identify/validation.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChannelType, IdentifyUserRequest, OptOut } from './types.js';\n\nconst CHANNEL_TYPES: ReadonlyArray<ChannelType> = [\n  'GCM',\n  'APNS',\n  'APNS_SANDBOX',\n  'IN_APP',\n];\nconst OPT_OUTS: ReadonlyArray<OptOut> = ['ALL', 'NONE'];\n\nexport type ValidationResult = {\n  ok: boolean;\n  error?: string;\n  value?: IdentifyUserRequest;\n};\n\nconst isPlainObject = (v: unknown): v is Record<string, unknown> =>\n  typeof v === 'object' && v !== null && !Array.isArray(v);\n\nconst isStringArray = (v: unknown): v is string[] =>\n  Array.isArray(v) && v.every((x) => typeof x === 'string');\n\nconst isStringMap = (v: unknown): v is Record<string, string[]> =>\n  isPlainObject(v) && Object.values(v).every((x) => isStringArray(x));\n\n/**\n * Validate the frozen identify-user request contract.\n *\n * Returns `{ ok: false, error }` on the first violation so the handler can map\n * it to a 400. Identity is NOT validated here — the verified `sub` is supplied\n * separately by the authorizer.\n */\nexport const validateBody = (body: unknown): ValidationResult => {\n  if (!isPlainObject(body)) {\n    return { ok: false, error: 'Request body must be a JSON object' };\n  }\n\n  if (body.userId !== undefined && typeof body.userId !== 'string') {\n    return { ok: false, error: 'userId must be a string when present' };\n  }\n\n  const userProfile = body.userProfile;\n  if (!isPlainObject(userProfile)) {\n    return {\n      ok: false,\n      error: 'userProfile is required and must be an object',\n    };\n  }\n\n  for (const key of ['name', 'email', 'plan'] as const) {\n    if (\n      userProfile[key] !== undefined &&\n      typeof userProfile[key] !== 'string'\n    ) {\n      return { ok: false, error: `userProfile.${key} must be a string` };\n    }\n  }\n\n  if (\n    userProfile.customProperties !== undefined &&\n    !isStringMap(userProfile.customProperties)\n  ) {\n    return {\n      ok: false,\n      error: 'userProfile.customProperties must be a map of string arrays',\n    };\n  }\n\n  if (userProfile.metrics !== undefined) {\n    if (\n      !isPlainObject(userProfile.metrics) ||\n      !Object.values(userProfile.metrics).every((n) => typeof n === 'number')\n    ) {\n      return {\n        ok: false,\n        error: 'userProfile.metrics must be a map of numbers',\n      };\n    }\n  }\n\n  const options = body.options;\n  if (options !== undefined) {\n    if (!isPlainObject(options)) {\n      return { ok: false, error: 'options must be an object when present' };\n    }\n    if (options.address !== undefined && typeof options.address !== 'string') {\n      return { ok: false, error: 'options.address must be a string' };\n    }\n    if (\n      options.deviceId !== undefined &&\n      typeof options.deviceId !== 'string'\n    ) {\n      return { ok: false, error: 'options.deviceId must be a string' };\n    }\n    if (\n      options.previousGuestIdentityId !== undefined &&\n      (typeof options.previousGuestIdentityId !== 'string' ||\n        options.previousGuestIdentityId.trim().length === 0 ||\n        options.previousGuestIdentityId.length > 128)\n    ) {\n      return {\n        ok: false,\n        error: 'options.previousGuestIdentityId must be a non-empty string',\n      };\n    }\n    if (\n      options.channelType !== undefined &&\n      !CHANNEL_TYPES.includes(options.channelType as ChannelType)\n    ) {\n      return {\n        ok: false,\n        error: `options.channelType must be one of ${CHANNEL_TYPES.join(', ')}`,\n      };\n    }\n    if (\n      options.optOut !== undefined &&\n      !OPT_OUTS.includes(options.optOut as OptOut)\n    ) {\n      return {\n        ok: false,\n        error: `options.optOut must be one of ${OPT_OUTS.join(', ')}`,\n      };\n    }\n    if (\n      options.userAttributes !== undefined &&\n      !isStringMap(options.userAttributes)\n    ) {\n      return {\n        ok: false,\n        error: 'options.userAttributes must be a map of string arrays',\n      };\n    }\n  }\n\n  return { ok: true, value: body as unknown as IdentifyUserRequest };\n};\n"]}

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

@@ -0,0 +1,49 @@
+import { CustomerProfilesClient } from '@aws-sdk/client-customer-profiles';
+import { PinpointClient } from '@aws-sdk/client-pinpoint';
+import { PushTemplateContext } from './message_template.js';
+import { ParsedPushEvent, ProfileDeliveryResult, ProfileTarget, PushChannelType, PushDeliveryResponse, PushMessage } from './types.js';
+/** Injected clients + resolved config for the delivery routines. */
+export type DeliveryDeps = {
+    profiles: CustomerProfilesClient;
+    pinpoint: PinpointClient;
+    /** Customer Profiles domain to resolve devices from. */
+    domainName: string;
+    /** AWS End User Messaging / Pinpoint application id to send from. */
+    applicationId: string;
+    /**
+     * The resolved Q in Connect PUSH message template for this journey run, when
+     * one was found (see {@link resolvePushTemplateContext}). When present, each
+     * profile's copy is rendered from the template (per-platform) and takes
+     * precedence over the safe DEFAULT copy; when absent, delivery uses the
+     * DEFAULT copy for every channel.
+     */
+    templateContext?: PushTemplateContext;
+};
+/**
+ * Resolve a single profile's registered devices and push the message to each
+ * via AWS End User Messaging, then clean up any device whose token was
+ * permanently rejected (stale-token cleanup).
+ *
+ * A device with an unsupported / missing channel (post-normalization) is
+ * recorded as a `SKIPPED` failure rather than being sent. A device whose
+ * delivery returns `PERMANENT_FAILURE` has its AmplifyDevice object deleted;
+ * the per-device result records whether that cleanup succeeded.
+ *
+ * `message` is the profile's fallback copy. When `perChannel` is supplied (from
+ * a rendered Q Connect template), the message for a device's channel is taken
+ * from it (falling back to `message` for any channel the template did not
+ * define), so iOS (`APNS`) and Android (`GCM`) devices can receive
+ * platform-specific copy.
+ */
+export declare const deliverToProfile: (deps: DeliveryDeps, target: ProfileTarget, message: PushMessage, perChannel?: Partial<Record<PushChannelType, PushMessage>>) => Promise<ProfileDeliveryResult>;
+/**
+ * Deliver to every targeted profile, aggregating a per-profile summary. Each
+ * profile's copy is resolved as: the rendered Q Connect PUSH template (per
+ * platform), falling back to the safe DEFAULT copy (`DEFAULT_PUSH_TITLE` /
+ * `DEFAULT_PUSH_BODY`) for any channel the template did not resolve for
+ * (no template, render miss, or the unresolved-placeholder guard rejected it).
+ * Profiles are processed sequentially to keep the per-profile Customer Profiles
+ * write ordering simple; batches are typically small per Journey invocation.
+ */
+export declare const deliverToTargets: (deps: DeliveryDeps, parsed: ParsedPushEvent) => Promise<PushDeliveryResponse>;
+//# sourceMappingURL=delivery.d.ts.map

package/lib/lambda/push/delivery.js

@@ -0,0 +1,120 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { deliverToDevice } from './eum_client.js';
+import { deleteDevice, listDevices } from './device_lookup.js';
+import { normalizeChannelType } from './payload.js';
+import { renderProfileChannelMessages, } from './message_template.js';
+/**
+ * Resolve a single profile's registered devices and push the message to each
+ * via AWS End User Messaging, then clean up any device whose token was
+ * permanently rejected (stale-token cleanup).
+ *
+ * A device with an unsupported / missing channel (post-normalization) is
+ * recorded as a `SKIPPED` failure rather than being sent. A device whose
+ * delivery returns `PERMANENT_FAILURE` has its AmplifyDevice object deleted;
+ * the per-device result records whether that cleanup succeeded.
+ *
+ * `message` is the profile's fallback copy. When `perChannel` is supplied (from
+ * a rendered Q Connect template), the message for a device's channel is taken
+ * from it (falling back to `message` for any channel the template did not
+ * define), so iOS (`APNS`) and Android (`GCM`) devices can receive
+ * platform-specific copy.
+ */
+export const deliverToProfile = async (deps, target, message, perChannel) => {
+    const { profiles, pinpoint, domainName, applicationId } = deps;
+    const devices = await listDevices(profiles, domainName, target.profileId);
+    const results = [];
+    let delivered = 0;
+    let failed = 0;
+    let cleaned = 0;
+    for (const device of devices) {
+        const channelType = normalizeChannelType(device.channelType);
+        if (!channelType) {
+            failed += 1;
+            results.push({
+                deviceToken: device.deviceToken,
+                channelType: 'GCM',
+                objectUniqueKey: device.objectUniqueKey,
+                status: 'SKIPPED',
+                delivered: false,
+                stale: false,
+                statusMessage: `Unsupported or missing channelType: ${device.channelType ?? '(none)'}`,
+            });
+            continue;
+        }
+        const channelMessage = perChannel?.[channelType] ?? message;
+        const outcome = await deliverToDevice(pinpoint, applicationId, device.deviceToken, channelType, channelMessage);
+        outcome.objectUniqueKey = device.objectUniqueKey;
+        results.push(outcome);
+        if (outcome.delivered) {
+            delivered += 1;
+        }
+        else {
+            failed += 1;
+        }
+        if (outcome.stale) {
+            // Cleanup decision only — no profile id or device token. `objectUniqueKey`
+            // is an opaque service-generated key needed to correlate the delete.
+            console.log('[push] cleanup.delete', JSON.stringify({
+                objectUniqueKey: device.objectUniqueKey,
+                channelType,
+                reason: outcome.statusMessage ?? outcome.status,
+            }));
+            const deletedOk = await deleteDevice(profiles, domainName, target.profileId, device.objectUniqueKey);
+            if (deletedOk) {
+                cleaned += 1;
+            }
+        }
+    }
+    return {
+        profileId: target.profileId,
+        delivered,
+        failed,
+        cleaned,
+        devices: results,
+    };
+};
+/**
+ * Deliver to every targeted profile, aggregating a per-profile summary. Each
+ * profile's copy is resolved as: the rendered Q Connect PUSH template (per
+ * platform), falling back to the safe DEFAULT copy (`DEFAULT_PUSH_TITLE` /
+ * `DEFAULT_PUSH_BODY`) for any channel the template did not resolve for
+ * (no template, render miss, or the unresolved-placeholder guard rejected it).
+ * Profiles are processed sequentially to keep the per-profile Customer Profiles
+ * write ordering simple; batches are typically small per Journey invocation.
+ */
+export const deliverToTargets = async (deps, parsed) => {
+    const results = [];
+    for (const target of parsed.targets) {
+        // The safe DEFAULT copy is the ONLY fallback: real journeys carry no
+        // per-profile or event-level message copy, so personalized copy comes
+        // solely from the rendered template below.
+        const fallback = parsed.message;
+        // When a Q Connect PUSH template was resolved for this journey run, render
+        // it per profile to get personalized, per-platform (APNS / GCM) copy that
+        // takes precedence over the default fallback. A render miss/failure (or a
+        // placeholder-guard rejection) leaves `perChannel` undefined so delivery
+        // uses the default copy.
+        let perChannel;
+        if (deps.templateContext) {
+            perChannel = await renderProfileChannelMessages(deps.templateContext, target);
+        }
+        // Operational signal only: whether a template applied and which channels it
+        // resolved copy for. The rendered / default title and body are NOT logged
+        // (they echo personalized customer copy); enable debug logging on the
+        // template renderer if the actual copy must be inspected.
+        console.log('[push] resolveMessage', JSON.stringify({
+            templateApplied: Boolean(perChannel),
+            channelsResolved: perChannel ? Object.keys(perChannel) : [],
+        }));
+        results.push(await deliverToProfile(deps, target, fallback, perChannel));
+    }
+    return {
+        profilesProcessed: results.length,
+        totalDelivered: results.reduce((n, r) => n + r.delivered, 0),
+        totalFailed: results.reduce((n, r) => n + r.failed, 0),
+        totalCleaned: results.reduce((n, r) => n + r.cleaned, 0),
+        results,
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"delivery.js","sourceRoot":"","sources":["../../../src/lambda/push/delivery.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 { CustomerProfilesClient } from '@aws-sdk/client-customer-profiles';\nimport { PinpointClient } from '@aws-sdk/client-pinpoint';\n\nimport { deliverToDevice } from './eum_client.js';\nimport { deleteDevice, listDevices } from './device_lookup.js';\nimport { normalizeChannelType } from './payload.js';\nimport {\n  PushTemplateContext,\n  renderProfileChannelMessages,\n} from './message_template.js';\nimport {\n  DeviceDeliveryResult,\n  ParsedPushEvent,\n  ProfileDeliveryResult,\n  ProfileTarget,\n  PushChannelType,\n  PushDeliveryResponse,\n  PushMessage,\n} from './types.js';\n\n/** Injected clients + resolved config for the delivery routines. */\nexport type DeliveryDeps = {\n  profiles: CustomerProfilesClient;\n  pinpoint: PinpointClient;\n  /** Customer Profiles domain to resolve devices from. */\n  domainName: string;\n  /** AWS End User Messaging / Pinpoint application id to send from. */\n  applicationId: string;\n  /**\n   * The resolved Q in Connect PUSH message template for this journey run, when\n   * one was found (see {@link resolvePushTemplateContext}). When present, each\n   * profile's copy is rendered from the template (per-platform) and takes\n   * precedence over the safe DEFAULT copy; when absent, delivery uses the\n   * DEFAULT copy for every channel.\n   */\n  templateContext?: PushTemplateContext;\n};\n\n/**\n * Resolve a single profile's registered devices and push the message to each\n * via AWS End User Messaging, then clean up any device whose token was\n * permanently rejected (stale-token cleanup).\n *\n * A device with an unsupported / missing channel (post-normalization) is\n * recorded as a `SKIPPED` failure rather than being sent. A device whose\n * delivery returns `PERMANENT_FAILURE` has its AmplifyDevice object deleted;\n * the per-device result records whether that cleanup succeeded.\n *\n * `message` is the profile's fallback copy. When `perChannel` is supplied (from\n * a rendered Q Connect template), the message for a device's channel is taken\n * from it (falling back to `message` for any channel the template did not\n * define), so iOS (`APNS`) and Android (`GCM`) devices can receive\n * platform-specific copy.\n */\nexport const deliverToProfile = async (\n  deps: DeliveryDeps,\n  target: ProfileTarget,\n  message: PushMessage,\n  perChannel?: Partial<Record<PushChannelType, PushMessage>>,\n): Promise<ProfileDeliveryResult> => {\n  const { profiles, pinpoint, domainName, applicationId } = deps;\n  const devices = await listDevices(profiles, domainName, target.profileId);\n\n  const results: DeviceDeliveryResult[] = [];\n  let delivered = 0;\n  let failed = 0;\n  let cleaned = 0;\n\n  for (const device of devices) {\n    const channelType = normalizeChannelType(device.channelType);\n    if (!channelType) {\n      failed += 1;\n      results.push({\n        deviceToken: device.deviceToken,\n        channelType: 'GCM',\n        objectUniqueKey: device.objectUniqueKey,\n        status: 'SKIPPED',\n        delivered: false,\n        stale: false,\n        statusMessage: `Unsupported or missing channelType: ${\n          device.channelType ?? '(none)'\n        }`,\n      });\n      continue;\n    }\n\n    const channelMessage = perChannel?.[channelType] ?? message;\n    const outcome = await deliverToDevice(\n      pinpoint,\n      applicationId,\n      device.deviceToken,\n      channelType,\n      channelMessage,\n    );\n    outcome.objectUniqueKey = device.objectUniqueKey;\n    results.push(outcome);\n\n    if (outcome.delivered) {\n      delivered += 1;\n    } else {\n      failed += 1;\n    }\n\n    if (outcome.stale) {\n      // Cleanup decision only — no profile id or device token. `objectUniqueKey`\n      // is an opaque service-generated key needed to correlate the delete.\n      console.log(\n        '[push] cleanup.delete',\n        JSON.stringify({\n          objectUniqueKey: device.objectUniqueKey,\n          channelType,\n          reason: outcome.statusMessage ?? outcome.status,\n        }),\n      );\n      const deletedOk = await deleteDevice(\n        profiles,\n        domainName,\n        target.profileId,\n        device.objectUniqueKey,\n      );\n      if (deletedOk) {\n        cleaned += 1;\n      }\n    }\n  }\n\n  return {\n    profileId: target.profileId,\n    delivered,\n    failed,\n    cleaned,\n    devices: results,\n  };\n};\n\n/**\n * Deliver to every targeted profile, aggregating a per-profile summary. Each\n * profile's copy is resolved as: the rendered Q Connect PUSH template (per\n * platform), falling back to the safe DEFAULT copy (`DEFAULT_PUSH_TITLE` /\n * `DEFAULT_PUSH_BODY`) for any channel the template did not resolve for\n * (no template, render miss, or the unresolved-placeholder guard rejected it).\n * Profiles are processed sequentially to keep the per-profile Customer Profiles\n * write ordering simple; batches are typically small per Journey invocation.\n */\nexport const deliverToTargets = async (\n  deps: DeliveryDeps,\n  parsed: ParsedPushEvent,\n): Promise<PushDeliveryResponse> => {\n  const results: ProfileDeliveryResult[] = [];\n  for (const target of parsed.targets) {\n    // The safe DEFAULT copy is the ONLY fallback: real journeys carry no\n    // per-profile or event-level message copy, so personalized copy comes\n    // solely from the rendered template below.\n    const fallback = parsed.message;\n\n    // When a Q Connect PUSH template was resolved for this journey run, render\n    // it per profile to get personalized, per-platform (APNS / GCM) copy that\n    // takes precedence over the default fallback. A render miss/failure (or a\n    // placeholder-guard rejection) leaves `perChannel` undefined so delivery\n    // uses the default copy.\n    let perChannel: Partial<Record<PushChannelType, PushMessage>> | undefined;\n    if (deps.templateContext) {\n      perChannel = await renderProfileChannelMessages(\n        deps.templateContext,\n        target,\n      );\n    }\n\n    // Operational signal only: whether a template applied and which channels it\n    // resolved copy for. The rendered / default title and body are NOT logged\n    // (they echo personalized customer copy); enable debug logging on the\n    // template renderer if the actual copy must be inspected.\n    console.log(\n      '[push] resolveMessage',\n      JSON.stringify({\n        templateApplied: Boolean(perChannel),\n        channelsResolved: perChannel ? Object.keys(perChannel) : [],\n      }),\n    );\n    results.push(await deliverToProfile(deps, target, fallback, perChannel));\n  }\n\n  return {\n    profilesProcessed: results.length,\n    totalDelivered: results.reduce((n, r) => n + r.delivered, 0),\n    totalFailed: results.reduce((n, r) => n + r.failed, 0),\n    totalCleaned: results.reduce((n, r) => n + r.cleaned, 0),\n    results,\n  };\n};\n"]}

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

@@ -0,0 +1,35 @@
+import { CustomerProfilesClient } from '@aws-sdk/client-customer-profiles';
+/** A registered device resolved from the profile's AmplifyDevice objects. */
+export type ResolvedDevice = {
+    /** The mutable push token / endpoint address. */
+    deviceToken: string;
+    /** The stored channel identifier (raw, pre-normalization). */
+    channelType?: string;
+    /** The stable device id, if present (for logging / diagnostics). */
+    deviceId?: string;
+    /**
+     * The service-generated ProfileObjectUniqueKey — required to delete the
+     * object during stale-token cleanup.
+     */
+    objectUniqueKey: string;
+};
+/**
+ * Resolve every registered device for a profile by paging through its
+ * AmplifyDevice objects (ListProfileObjects) and extracting the push token +
+ * channel + the ProfileObjectUniqueKey (needed for deletion).
+ *
+ * Device objects missing a token are skipped. Malformed stored objects are
+ * ignored rather than aborting the whole profile. Wrapped in
+ * {@link withTransientRetry} so transient throttling is retried with backoff.
+ */
+export declare const listDevices: (profiles: CustomerProfilesClient, domainName: string, profileId: string) => Promise<ResolvedDevice[]>;
+/**
+ * Delete a single AmplifyDevice object (stale-token cleanup) after its token
+ * was permanently rejected. Best-effort: a failed delete is swallowed so it
+ * never masks the delivery result — the object simply lingers until the next
+ * cleanup or its TTL expiry.
+ *
+ * Returns `true` when the delete succeeded, `false` otherwise.
+ */
+export declare const deleteDevice: (profiles: CustomerProfilesClient, domainName: string, profileId: string, objectUniqueKey: string) => Promise<boolean>;
+//# sourceMappingURL=device_lookup.d.ts.map

package/lib/lambda/push/device_lookup.js

@@ -0,0 +1,88 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { DeleteProfileObjectCommand, ListProfileObjectsCommand, } from '@aws-sdk/client-customer-profiles';
+import { OBJECT_TYPE_DEVICE } from '../../constants.js';
+import { withTransientRetry } from '../shared/retry.js';
+/**
+ * Resolve every registered device for a profile by paging through its
+ * AmplifyDevice objects (ListProfileObjects) and extracting the push token +
+ * channel + the ProfileObjectUniqueKey (needed for deletion).
+ *
+ * Device objects missing a token are skipped. Malformed stored objects are
+ * ignored rather than aborting the whole profile. Wrapped in
+ * {@link withTransientRetry} so transient throttling is retried with backoff.
+ */
+export const listDevices = async (profiles, domainName, profileId) => {
+    const devices = [];
+    let nextToken;
+    do {
+        const res = await withTransientRetry(() => profiles.send(new ListProfileObjectsCommand({
+            DomainName: domainName,
+            ObjectTypeName: OBJECT_TYPE_DEVICE,
+            ProfileId: profileId,
+            NextToken: nextToken,
+        })));
+        for (const item of res.Items ?? []) {
+            const uniqueKey = item.ProfileObjectUniqueKey;
+            if (!item.Object || !uniqueKey) {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(item.Object);
+            }
+            catch {
+                continue;
+            }
+            const deviceToken = typeof parsed.deviceToken === 'string' ? parsed.deviceToken : undefined;
+            if (!deviceToken) {
+                continue;
+            }
+            devices.push({
+                deviceToken,
+                channelType: typeof parsed.channelType === 'string'
+                    ? parsed.channelType
+                    : undefined,
+                deviceId: typeof parsed.deviceId === 'string' ? parsed.deviceId : undefined,
+                objectUniqueKey: uniqueKey,
+            });
+        }
+        nextToken = res.NextToken;
+    } while (nextToken);
+    // Operational signal only: how many devices resolved and their channel types
+    // (non-personal). Profile id, device ids and tokens are NOT logged.
+    console.log('[push] devices.resolved', JSON.stringify({
+        count: devices.length,
+        channelTypes: devices.map((d) => d.channelType ?? '(none)'),
+    }));
+    return devices;
+};
+/**
+ * Delete a single AmplifyDevice object (stale-token cleanup) after its token
+ * was permanently rejected. Best-effort: a failed delete is swallowed so it
+ * never masks the delivery result — the object simply lingers until the next
+ * cleanup or its TTL expiry.
+ *
+ * Returns `true` when the delete succeeded, `false` otherwise.
+ */
+export const deleteDevice = async (profiles, domainName, profileId, objectUniqueKey) => {
+    try {
+        await withTransientRetry(() => profiles.send(new DeleteProfileObjectCommand({
+            DomainName: domainName,
+            ProfileId: profileId,
+            ObjectTypeName: OBJECT_TYPE_DEVICE,
+            ProfileObjectUniqueKey: objectUniqueKey,
+        })));
+        return true;
+    }
+    catch (err) {
+        // Log the failure name / object key only — no profile id and no raw error
+        // object (which can carry request content).
+        console.error('[push] cleanup.deleteFailed', JSON.stringify({
+            objectUniqueKey,
+            error: err instanceof Error ? err.name : 'unknown',
+        }));
+        return false;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"device_lookup.js","sourceRoot":"","sources":["../../../src/lambda/push/device_lookup.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  CustomerProfilesClient,\n  DeleteProfileObjectCommand,\n  ListProfileObjectsCommand,\n} from '@aws-sdk/client-customer-profiles';\n\nimport { OBJECT_TYPE_DEVICE } from '../../constants.js';\nimport { withTransientRetry } from '../shared/retry.js';\n\n/** A registered device resolved from the profile's AmplifyDevice objects. */\nexport type ResolvedDevice = {\n  /** The mutable push token / endpoint address. */\n  deviceToken: string;\n  /** The stored channel identifier (raw, pre-normalization). */\n  channelType?: string;\n  /** The stable device id, if present (for logging / diagnostics). */\n  deviceId?: string;\n  /**\n   * The service-generated ProfileObjectUniqueKey — required to delete the\n   * object during stale-token cleanup.\n   */\n  objectUniqueKey: string;\n};\n\n/**\n * Resolve every registered device for a profile by paging through its\n * AmplifyDevice objects (ListProfileObjects) and extracting the push token +\n * channel + the ProfileObjectUniqueKey (needed for deletion).\n *\n * Device objects missing a token are skipped. Malformed stored objects are\n * ignored rather than aborting the whole profile. Wrapped in\n * {@link withTransientRetry} so transient throttling is retried with backoff.\n */\nexport const listDevices = async (\n  profiles: CustomerProfilesClient,\n  domainName: string,\n  profileId: string,\n): Promise<ResolvedDevice[]> => {\n  const devices: ResolvedDevice[] = [];\n  let nextToken: string | undefined;\n\n  do {\n    const res = await withTransientRetry(() =>\n      profiles.send(\n        new ListProfileObjectsCommand({\n          DomainName: domainName,\n          ObjectTypeName: OBJECT_TYPE_DEVICE,\n          ProfileId: profileId,\n          NextToken: nextToken,\n        }),\n      ),\n    );\n\n    for (const item of res.Items ?? []) {\n      const uniqueKey = item.ProfileObjectUniqueKey;\n      if (!item.Object || !uniqueKey) {\n        continue;\n      }\n      let parsed: Record<string, unknown>;\n      try {\n        parsed = JSON.parse(item.Object) as Record<string, unknown>;\n      } catch {\n        continue;\n      }\n      const deviceToken =\n        typeof parsed.deviceToken === 'string' ? parsed.deviceToken : undefined;\n      if (!deviceToken) {\n        continue;\n      }\n      devices.push({\n        deviceToken,\n        channelType:\n          typeof parsed.channelType === 'string'\n            ? parsed.channelType\n            : undefined,\n        deviceId:\n          typeof parsed.deviceId === 'string' ? parsed.deviceId : undefined,\n        objectUniqueKey: uniqueKey,\n      });\n    }\n    nextToken = res.NextToken;\n  } while (nextToken);\n\n  // Operational signal only: how many devices resolved and their channel types\n  // (non-personal). Profile id, device ids and tokens are NOT logged.\n  console.log(\n    '[push] devices.resolved',\n    JSON.stringify({\n      count: devices.length,\n      channelTypes: devices.map((d) => d.channelType ?? '(none)'),\n    }),\n  );\n\n  return devices;\n};\n\n/**\n * Delete a single AmplifyDevice object (stale-token cleanup) after its token\n * was permanently rejected. Best-effort: a failed delete is swallowed so it\n * never masks the delivery result — the object simply lingers until the next\n * cleanup or its TTL expiry.\n *\n * Returns `true` when the delete succeeded, `false` otherwise.\n */\nexport const deleteDevice = async (\n  profiles: CustomerProfilesClient,\n  domainName: string,\n  profileId: string,\n  objectUniqueKey: string,\n): Promise<boolean> => {\n  try {\n    await withTransientRetry(() =>\n      profiles.send(\n        new DeleteProfileObjectCommand({\n          DomainName: domainName,\n          ProfileId: profileId,\n          ObjectTypeName: OBJECT_TYPE_DEVICE,\n          ProfileObjectUniqueKey: objectUniqueKey,\n        }),\n      ),\n    );\n    return true;\n  } catch (err) {\n    // Log the failure name / object key only — no profile id and no raw error\n    // object (which can carry request content).\n    console.error(\n      '[push] cleanup.deleteFailed',\n      JSON.stringify({\n        objectUniqueKey,\n        error: err instanceof Error ? err.name : 'unknown',\n      }),\n    );\n    return false;\n  }\n};\n"]}

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

@@ -0,0 +1,31 @@
+import { PinpointClient } from '@aws-sdk/client-pinpoint';
+import { DeviceDeliveryResult, PushChannelType, PushMessage } from './types.js';
+/**
+ * Decide whether a per-address delivery failure represents a permanently
+ * invalid TOKEN (safe to delete) versus a channel / app misconfiguration or
+ * transient error (keep the token).
+ *
+ * Conservative by design: returns `true` ONLY for a `PERMANENT_FAILURE` whose
+ * `StatusMessage` matches a known invalid-token indicator. The default for any
+ * ambiguous or unknown failure is `false` (keep the device).
+ */
+export declare const isInvalidTokenFailure: (status: string, statusMessage: string | undefined) => boolean;
+/**
+ * Deliver a single push to one device via AWS End User Messaging (Pinpoint
+ * `SendMessages`), addressing the message to the device token on its channel.
+ *
+ * Returns a structured per-device result classifying the Pinpoint
+ * `DeliveryStatus` into delivered / failed and flagging ONLY a genuinely
+ * invalid token as `stale` (via {@link isInvalidTokenFailure}) so the caller
+ * can delete its device object. A thrown call (e.g. the channel is not
+ * configured on the EUM app) is caught and reported as `status: 'ERROR'`
+ * (failed, NOT stale — the token itself may be fine).
+ *
+ * Emits greppable `[push] send.response` / `[push] classify` log lines carrying
+ * the request channel and the per-address response (DeliveryStatus /
+ * StatusCode / StatusMessage) plus the keep-vs-delete decision, so a failed
+ * send can be diagnosed as channel-not-enabled vs invalid-token from the logs.
+ * These carry NO device token, profile id, or message copy.
+ */
+export declare const deliverToDevice: (pinpoint: PinpointClient, applicationId: string, deviceToken: string, channelType: PushChannelType, message: PushMessage) => Promise<DeviceDeliveryResult>;
+//# sourceMappingURL=eum_client.d.ts.map