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

package/lib/lambda/shared/retry.js

@@ -0,0 +1,45 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * 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 const isTransientConcurrentUpdate = (err) => {
+    const name = err?.name ?? '';
+    const msg = err?.message ?? '';
+    return (((name === 'BadRequestException' ||
+        name === 'ThrottlingException' ||
+        name === 'TooManyRequestsException') &&
+        /concurrent update in-progress|too many requests|rate exceeded/i.test(msg)) ||
+        name === 'ThrottlingException' ||
+        name === 'TooManyRequestsException');
+};
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * Run `fn`, retrying on transient concurrent-update / throttling errors with
+ * exponential backoff + full jitter. Non-transient errors propagate immediately.
+ */
+export const withTransientRetry = async (fn, opts = {}) => {
+    const attempts = opts.attempts ?? 6;
+    const baseDelayMs = opts.baseDelayMs ?? 80;
+    let lastErr;
+    for (let i = 0; i < attempts; i++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            if (!isTransientConcurrentUpdate(err) || i === attempts - 1) {
+                throw err;
+            }
+            const ceiling = baseDelayMs * 2 ** i;
+            await sleep(Math.floor(Math.random() * ceiling));
+        }
+    }
+    throw lastErr;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/object_types.d.ts

@@ -0,0 +1,63 @@
+import type { CfnObjectType } from 'aws-cdk-lib/aws-customerprofiles';
+export type FieldMap = CfnObjectType.FieldMapProperty;
+export type KeyMap = CfnObjectType.KeyMapProperty;
+/**
+ * AmplifyProfile — the AUTHENTICATED person profile object type.
+ *
+ * Single searchable identity key `cognitoUserKey` (PROFILE + UNIQUE) sourced
+ * from `cognitoSub`. The Lambda ingests a minimal `{cognitoSub}` object via
+ * PutProfileObject purely for the atomic find-or-create by that UNIQUE key;
+ * person / targeting attributes are written separately by UpdateProfile.
+ *
+ * `allowProfileCreation` stays true so ingesting an object with a new
+ * `cognitoSub` creates the profile, and re-ingesting an existing one resolves
+ * to it in place. (Customer Profiles requires the ingested object to carry the
+ * object type's UNIQUE key — the reason guest profiles need their own type.)
+ */
+export declare const AMPLIFY_PROFILE_FIELDS: FieldMap[];
+export declare const AMPLIFY_PROFILE_KEYS: KeyMap[];
+/**
+ * AmplifyGuestProfile — the GUEST person profile object type.
+ *
+ * A distinct object type is required: Customer Profiles allows EXACTLY ONE
+ * `UNIQUE` key per object type and `PutProfileObject` rejects an object that
+ * does not carry that UNIQUE key. The authed `AmplifyProfile` reserves its
+ * UNIQUE key for `cognitoSub`, so guest profiles get their own type whose
+ * single UNIQUE key is `cognitoIdentityKey`, sourced from the Identity Pool
+ * `cognitoIdentityId` (e.g. `us-east-1:<uuid>`).
+ *
+ * Guest profiles are created in the SAME domain, so a SearchProfiles by
+ * `cognitoIdentityKey` and a later MergeProfiles into the authed profile work
+ * uniformly. On sign-in the guest profile is folded into the authed
+ * (sub-keyed) profile via MergeProfiles (see merge_resolver).
+ */
+export declare const AMPLIFY_GUEST_PROFILE_FIELDS: FieldMap[];
+export declare const AMPLIFY_GUEST_PROFILE_KEYS: KeyMap[];
+/**
+ * AmplifyDevice — one object per stable device.
+ *
+ * UNIQUE object key = `deviceId` (stable), so a push-token refresh for the same
+ * device upserts the same object in place. The full ingested object carries the
+ * device schema: `deviceToken` (mutable push token), `channelType`, `platform`,
+ * `appVersion`, `createdAt` (immutable first-registration time, preserved
+ * across writes by the handler) and `updatedAt` (server-set on every write).
+ * Those non-key fields are NOT mapped to a target: Customer Profiles stores the
+ * ingested object verbatim and returns it from ListProfileObjects, so they
+ * survive refreshes without a field mapping. Only the key fields need targets,
+ * and CP requires targets under a reserved namespace (there is no `_object.*`
+ * namespace), so the keys map into `_profile.Attributes.*`.
+ *
+ * TWO profile-resolution keys (both PROFILE, not UNIQUE) let a device merge into
+ * EITHER the authed profile (via `cognitoUserKey` from `cognitoSub`) or the
+ * GUEST profile (via `cognitoIdentityKey` from `cognitoIdentityId`), depending
+ * on which identity field the ingested object carries. The object always
+ * carries the UNIQUE `deviceId`, so ingestion is valid for both.
+ */
+export declare const AMPLIFY_DEVICE_FIELDS: FieldMap[];
+export declare const AMPLIFY_DEVICE_KEYS: KeyMap[];
+export declare const OBJECT_TYPE_NAMES: {
+    profile: string;
+    guestProfile: string;
+    device: string;
+};
+//# sourceMappingURL=object_types.d.ts.map

package/lib/object_types.js

@@ -0,0 +1,131 @@
+import { COGNITO_IDENTITY_FIELD, COGNITO_IDENTITY_KEY, COGNITO_USER_KEY, OBJECT_TYPE_DEVICE, OBJECT_TYPE_GUEST_PROFILE, OBJECT_TYPE_PROFILE, } from './constants.js';
+const field = (name, source, target) => ({
+    name,
+    objectTypeField: {
+        contentType: 'STRING',
+        source: `_source.${source}`,
+        target,
+    },
+});
+/**
+ * AmplifyProfile — the AUTHENTICATED person profile object type.
+ *
+ * Single searchable identity key `cognitoUserKey` (PROFILE + UNIQUE) sourced
+ * from `cognitoSub`. The Lambda ingests a minimal `{cognitoSub}` object via
+ * PutProfileObject purely for the atomic find-or-create by that UNIQUE key;
+ * person / targeting attributes are written separately by UpdateProfile.
+ *
+ * `allowProfileCreation` stays true so ingesting an object with a new
+ * `cognitoSub` creates the profile, and re-ingesting an existing one resolves
+ * to it in place. (Customer Profiles requires the ingested object to carry the
+ * object type's UNIQUE key — the reason guest profiles need their own type.)
+ */
+export const AMPLIFY_PROFILE_FIELDS = [
+    field('cognitoSub', 'cognitoSub', '_profile.Attributes.cognitoSub'),
+];
+export const AMPLIFY_PROFILE_KEYS = [
+    {
+        // Searchable AUTHENTICATED identity key: SearchProfiles(cognitoUserKey,...).
+        name: COGNITO_USER_KEY,
+        objectTypeKeyList: [
+            {
+                standardIdentifiers: ['PROFILE', 'UNIQUE'],
+                fieldNames: ['cognitoSub'],
+            },
+        ],
+    },
+];
+/**
+ * AmplifyGuestProfile — the GUEST person profile object type.
+ *
+ * A distinct object type is required: Customer Profiles allows EXACTLY ONE
+ * `UNIQUE` key per object type and `PutProfileObject` rejects an object that
+ * does not carry that UNIQUE key. The authed `AmplifyProfile` reserves its
+ * UNIQUE key for `cognitoSub`, so guest profiles get their own type whose
+ * single UNIQUE key is `cognitoIdentityKey`, sourced from the Identity Pool
+ * `cognitoIdentityId` (e.g. `us-east-1:<uuid>`).
+ *
+ * Guest profiles are created in the SAME domain, so a SearchProfiles by
+ * `cognitoIdentityKey` and a later MergeProfiles into the authed profile work
+ * uniformly. On sign-in the guest profile is folded into the authed
+ * (sub-keyed) profile via MergeProfiles (see merge_resolver).
+ */
+export const AMPLIFY_GUEST_PROFILE_FIELDS = [
+    field(COGNITO_IDENTITY_FIELD, COGNITO_IDENTITY_FIELD, '_profile.Attributes.cognitoIdentityId'),
+];
+export const AMPLIFY_GUEST_PROFILE_KEYS = [
+    {
+        // Searchable GUEST identity key: SearchProfiles(cognitoIdentityKey,...).
+        // The single UNIQUE key on the guest object type.
+        name: COGNITO_IDENTITY_KEY,
+        objectTypeKeyList: [
+            {
+                standardIdentifiers: ['PROFILE', 'UNIQUE'],
+                fieldNames: [COGNITO_IDENTITY_FIELD],
+            },
+        ],
+    },
+];
+/**
+ * AmplifyDevice — one object per stable device.
+ *
+ * UNIQUE object key = `deviceId` (stable), so a push-token refresh for the same
+ * device upserts the same object in place. The full ingested object carries the
+ * device schema: `deviceToken` (mutable push token), `channelType`, `platform`,
+ * `appVersion`, `createdAt` (immutable first-registration time, preserved
+ * across writes by the handler) and `updatedAt` (server-set on every write).
+ * Those non-key fields are NOT mapped to a target: Customer Profiles stores the
+ * ingested object verbatim and returns it from ListProfileObjects, so they
+ * survive refreshes without a field mapping. Only the key fields need targets,
+ * and CP requires targets under a reserved namespace (there is no `_object.*`
+ * namespace), so the keys map into `_profile.Attributes.*`.
+ *
+ * TWO profile-resolution keys (both PROFILE, not UNIQUE) let a device merge into
+ * EITHER the authed profile (via `cognitoUserKey` from `cognitoSub`) or the
+ * GUEST profile (via `cognitoIdentityKey` from `cognitoIdentityId`), depending
+ * on which identity field the ingested object carries. The object always
+ * carries the UNIQUE `deviceId`, so ingestion is valid for both.
+ */
+export const AMPLIFY_DEVICE_FIELDS = [
+    field('cognitoSub', 'cognitoSub', '_profile.Attributes.cognitoSub'),
+    field(COGNITO_IDENTITY_FIELD, COGNITO_IDENTITY_FIELD, '_profile.Attributes.cognitoIdentityId'),
+    field('deviceId', 'deviceId', '_profile.Attributes.deviceId'),
+];
+export const AMPLIFY_DEVICE_KEYS = [
+    {
+        // Profile-resolution key (authed): merges the device into the sub's profile.
+        name: COGNITO_USER_KEY,
+        objectTypeKeyList: [
+            {
+                standardIdentifiers: ['PROFILE'],
+                fieldNames: ['cognitoSub'],
+            },
+        ],
+    },
+    {
+        // Profile-resolution key (guest): merges the device into the guest profile.
+        name: COGNITO_IDENTITY_KEY,
+        objectTypeKeyList: [
+            {
+                standardIdentifiers: ['PROFILE'],
+                fieldNames: [COGNITO_IDENTITY_FIELD],
+            },
+        ],
+    },
+    {
+        // Stable unique object key: token refresh updates this object in place.
+        name: 'deviceId',
+        objectTypeKeyList: [
+            {
+                standardIdentifiers: ['UNIQUE'],
+                fieldNames: ['deviceId'],
+            },
+        ],
+    },
+];
+export const OBJECT_TYPE_NAMES = {
+    profile: OBJECT_TYPE_PROFILE,
+    guestProfile: OBJECT_TYPE_GUEST_PROFILE,
+    device: OBJECT_TYPE_DEVICE,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object_types.js","sourceRoot":"","sources":["../src/object_types.ts"],"names":[],"mappings":"AACA,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,yBAAyB,EACzB,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AAKxB,MAAM,KAAK,GAAG,CAAC,IAAY,EAAE,MAAc,EAAE,MAAc,EAAY,EAAE,CAAC,CAAC;IACzE,IAAI;IACJ,eAAe,EAAE;QACf,WAAW,EAAE,QAAQ;QACrB,MAAM,EAAE,WAAW,MAAM,EAAE;QAC3B,MAAM;KACP;CACF,CAAC,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAe;IAChD,KAAK,CAAC,YAAY,EAAE,YAAY,EAAE,gCAAgC,CAAC;CACpE,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAa;IAC5C;QACE,6EAA6E;QAC7E,IAAI,EAAE,gBAAgB;QACtB,iBAAiB,EAAE;YACjB;gBACE,mBAAmB,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC;gBAC1C,UAAU,EAAE,CAAC,YAAY,CAAC;aAC3B;SACF;KACF;CACF,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAe;IACtD,KAAK,CACH,sBAAsB,EACtB,sBAAsB,EACtB,uCAAuC,CACxC;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,0BAA0B,GAAa;IAClD;QACE,yEAAyE;QACzE,kDAAkD;QAClD,IAAI,EAAE,oBAAoB;QAC1B,iBAAiB,EAAE;YACjB;gBACE,mBAAmB,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC;gBAC1C,UAAU,EAAE,CAAC,sBAAsB,CAAC;aACrC;SACF;KACF;CACF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAe;IAC/C,KAAK,CAAC,YAAY,EAAE,YAAY,EAAE,gCAAgC,CAAC;IACnE,KAAK,CACH,sBAAsB,EACtB,sBAAsB,EACtB,uCAAuC,CACxC;IACD,KAAK,CAAC,UAAU,EAAE,UAAU,EAAE,8BAA8B,CAAC;CAC9D,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAa;IAC3C;QACE,6EAA6E;QAC7E,IAAI,EAAE,gBAAgB;QACtB,iBAAiB,EAAE;YACjB;gBACE,mBAAmB,EAAE,CAAC,SAAS,CAAC;gBAChC,UAAU,EAAE,CAAC,YAAY,CAAC;aAC3B;SACF;KACF;IACD;QACE,4EAA4E;QAC5E,IAAI,EAAE,oBAAoB;QAC1B,iBAAiB,EAAE;YACjB;gBACE,mBAAmB,EAAE,CAAC,SAAS,CAAC;gBAChC,UAAU,EAAE,CAAC,sBAAsB,CAAC;aACrC;SACF;KACF;IACD;QACE,wEAAwE;QACxE,IAAI,EAAE,UAAU;QAChB,iBAAiB,EAAE;YACjB;gBACE,mBAAmB,EAAE,CAAC,QAAQ,CAAC;gBAC/B,UAAU,EAAE,CAAC,UAAU,CAAC;aACzB;SACF;KACF;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,OAAO,EAAE,mBAAmB;IAC5B,YAAY,EAAE,yBAAyB;IACvC,MAAM,EAAE,kBAAkB;CAC3B,CAAC","sourcesContent":["import type { CfnObjectType } from 'aws-cdk-lib/aws-customerprofiles';\nimport {\n  COGNITO_IDENTITY_FIELD,\n  COGNITO_IDENTITY_KEY,\n  COGNITO_USER_KEY,\n  OBJECT_TYPE_DEVICE,\n  OBJECT_TYPE_GUEST_PROFILE,\n  OBJECT_TYPE_PROFILE,\n} from './constants.js';\n\nexport type FieldMap = CfnObjectType.FieldMapProperty;\nexport type KeyMap = CfnObjectType.KeyMapProperty;\n\nconst field = (name: string, source: string, target: string): FieldMap => ({\n  name,\n  objectTypeField: {\n    contentType: 'STRING',\n    source: `_source.${source}`,\n    target,\n  },\n});\n\n/**\n * AmplifyProfile — the AUTHENTICATED person profile object type.\n *\n * Single searchable identity key `cognitoUserKey` (PROFILE + UNIQUE) sourced\n * from `cognitoSub`. The Lambda ingests a minimal `{cognitoSub}` object via\n * PutProfileObject purely for the atomic find-or-create by that UNIQUE key;\n * person / targeting attributes are written separately by UpdateProfile.\n *\n * `allowProfileCreation` stays true so ingesting an object with a new\n * `cognitoSub` creates the profile, and re-ingesting an existing one resolves\n * to it in place. (Customer Profiles requires the ingested object to carry the\n * object type's UNIQUE key — the reason guest profiles need their own type.)\n */\nexport const AMPLIFY_PROFILE_FIELDS: FieldMap[] = [\n  field('cognitoSub', 'cognitoSub', '_profile.Attributes.cognitoSub'),\n];\n\nexport const AMPLIFY_PROFILE_KEYS: KeyMap[] = [\n  {\n    // Searchable AUTHENTICATED identity key: SearchProfiles(cognitoUserKey,...).\n    name: COGNITO_USER_KEY,\n    objectTypeKeyList: [\n      {\n        standardIdentifiers: ['PROFILE', 'UNIQUE'],\n        fieldNames: ['cognitoSub'],\n      },\n    ],\n  },\n];\n\n/**\n * AmplifyGuestProfile — the GUEST person profile object type.\n *\n * A distinct object type is required: Customer Profiles allows EXACTLY ONE\n * `UNIQUE` key per object type and `PutProfileObject` rejects an object that\n * does not carry that UNIQUE key. The authed `AmplifyProfile` reserves its\n * UNIQUE key for `cognitoSub`, so guest profiles get their own type whose\n * single UNIQUE key is `cognitoIdentityKey`, sourced from the Identity Pool\n * `cognitoIdentityId` (e.g. `us-east-1:<uuid>`).\n *\n * Guest profiles are created in the SAME domain, so a SearchProfiles by\n * `cognitoIdentityKey` and a later MergeProfiles into the authed profile work\n * uniformly. On sign-in the guest profile is folded into the authed\n * (sub-keyed) profile via MergeProfiles (see merge_resolver).\n */\nexport const AMPLIFY_GUEST_PROFILE_FIELDS: FieldMap[] = [\n  field(\n    COGNITO_IDENTITY_FIELD,\n    COGNITO_IDENTITY_FIELD,\n    '_profile.Attributes.cognitoIdentityId',\n  ),\n];\n\nexport const AMPLIFY_GUEST_PROFILE_KEYS: KeyMap[] = [\n  {\n    // Searchable GUEST identity key: SearchProfiles(cognitoIdentityKey,...).\n    // The single UNIQUE key on the guest object type.\n    name: COGNITO_IDENTITY_KEY,\n    objectTypeKeyList: [\n      {\n        standardIdentifiers: ['PROFILE', 'UNIQUE'],\n        fieldNames: [COGNITO_IDENTITY_FIELD],\n      },\n    ],\n  },\n];\n\n/**\n * AmplifyDevice — one object per stable device.\n *\n * UNIQUE object key = `deviceId` (stable), so a push-token refresh for the same\n * device upserts the same object in place. The full ingested object carries the\n * device schema: `deviceToken` (mutable push token), `channelType`, `platform`,\n * `appVersion`, `createdAt` (immutable first-registration time, preserved\n * across writes by the handler) and `updatedAt` (server-set on every write).\n * Those non-key fields are NOT mapped to a target: Customer Profiles stores the\n * ingested object verbatim and returns it from ListProfileObjects, so they\n * survive refreshes without a field mapping. Only the key fields need targets,\n * and CP requires targets under a reserved namespace (there is no `_object.*`\n * namespace), so the keys map into `_profile.Attributes.*`.\n *\n * TWO profile-resolution keys (both PROFILE, not UNIQUE) let a device merge into\n * EITHER the authed profile (via `cognitoUserKey` from `cognitoSub`) or the\n * GUEST profile (via `cognitoIdentityKey` from `cognitoIdentityId`), depending\n * on which identity field the ingested object carries. The object always\n * carries the UNIQUE `deviceId`, so ingestion is valid for both.\n */\nexport const AMPLIFY_DEVICE_FIELDS: FieldMap[] = [\n  field('cognitoSub', 'cognitoSub', '_profile.Attributes.cognitoSub'),\n  field(\n    COGNITO_IDENTITY_FIELD,\n    COGNITO_IDENTITY_FIELD,\n    '_profile.Attributes.cognitoIdentityId',\n  ),\n  field('deviceId', 'deviceId', '_profile.Attributes.deviceId'),\n];\n\nexport const AMPLIFY_DEVICE_KEYS: KeyMap[] = [\n  {\n    // Profile-resolution key (authed): merges the device into the sub's profile.\n    name: COGNITO_USER_KEY,\n    objectTypeKeyList: [\n      {\n        standardIdentifiers: ['PROFILE'],\n        fieldNames: ['cognitoSub'],\n      },\n    ],\n  },\n  {\n    // Profile-resolution key (guest): merges the device into the guest profile.\n    name: COGNITO_IDENTITY_KEY,\n    objectTypeKeyList: [\n      {\n        standardIdentifiers: ['PROFILE'],\n        fieldNames: [COGNITO_IDENTITY_FIELD],\n      },\n    ],\n  },\n  {\n    // Stable unique object key: token refresh updates this object in place.\n    name: 'deviceId',\n    objectTypeKeyList: [\n      {\n        standardIdentifiers: ['UNIQUE'],\n        fieldNames: ['deviceId'],\n      },\n    ],\n  },\n];\n\nexport const OBJECT_TYPE_NAMES = {\n  profile: OBJECT_TYPE_PROFILE,\n  guestProfile: OBJECT_TYPE_GUEST_PROFILE,\n  device: OBJECT_TYPE_DEVICE,\n};\n"]}