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

package/lib/factory.d.ts

@@ -0,0 +1,53 @@
+import { ConstructFactory } from '@aws-amplify/plugin-types';
+import { AmplifyNotifications } from './construct.js';
+import { NotificationsFactoryProps } from './types.js';
+/**
+ * Include an Amazon Connect Customer Profiles-backed notifications resource in
+ * your Amplify backend. It registers the AmplifyProfile / AmplifyDevice object
+ * types, a least-privilege identify-user Lambda + a JWT-authorized HTTP API, and
+ * the push-delivery Lambda (invoked by a Connect Journey Custom-action) with a
+ * minimal AWS End User Messaging application. The invoke endpoint / region /
+ * domain name are surfaced under `custom.CustomerProfiles` in
+ * `amplify_outputs.json`.
+ *
+ * By DEFAULT (no `domainName`) it CREATES FROM SCRATCH: a brand-new Amazon
+ * Connect instance AND a brand-new Customer Profiles domain (generated, stable
+ * names) are provisioned and the object types are registered into that new
+ * domain — zero pre-existing Connect setup required, and Connect is fully hidden
+ * from the caller.
+ *
+ * Provide `domainName` to ATTACH to an EXISTING Customer Profiles domain — e.g.
+ * the domain Amazon Connect auto-creates for your instance — registering the
+ * object types into it (additive), without creating an instance or a domain.
+ *
+ * Optionally provide `apns` and/or `fcm` to enable the corresponding push
+ * channel on the created End User Messaging (Pinpoint) application. The
+ * sensitive key material (APNs `.p8`, FCM service-account JSON) is supplied via
+ * Amplify `secret()` and resolved at deploy time; non-secret identifiers are
+ * plain props. Omit them to leave the channels not configured (unchanged
+ * behavior).
+ * @example
+ * import { defineBackend } from '@aws-amplify/backend';
+ * import { defineNotifications } from '@aws-amplify/backend-notifications';
+ * import { auth } from './auth/resource';
+ * import { secret } from '@aws-amplify/backend';
+ *
+ * defineBackend({
+ *   auth,
+ *   // Zero-config: creates a Connect instance + Customer Profiles domain:
+ *   notifications: defineNotifications(),
+ *   // ...or attach to an existing domain and enable push channels:
+ *   // notifications: defineNotifications({
+ *   //   domainName: 'amazon-connect-amplify',
+ *   //   apns: {
+ *   //     keySecret: secret('APNS_SIGNING_KEY'),
+ *   //     keyId: 'ABC123DEFG',
+ *   //     teamId: 'DEF456GHIJ',
+ *   //     bundleId: 'com.example.app',
+ *   //   },
+ *   //   fcm: { credentialsSecret: secret('FCM_SERVICE_ACCOUNT_JSON') },
+ *   // }),
+ * });
+ */
+export declare const defineNotifications: (props?: NotificationsFactoryProps) => ConstructFactory<AmplifyNotifications>;
+//# sourceMappingURL=factory.d.ts.map

package/lib/factory.js

@@ -0,0 +1,158 @@
+import { Stack } from 'aws-cdk-lib';
+import { customOutputKey } from '@aws-amplify/backend-output-schemas';
+import { AmplifyUserError } from '@aws-amplify/platform-core';
+import { AmplifyNotifications } from './construct.js';
+import { OUTPUT_KEY } from './constants.js';
+/**
+ * Generates the {@link AmplifyNotifications} construct in the resolved stack,
+ * wiring the HTTP API's JWT authorizer to the app's Cognito user pool.
+ */
+class NotificationsGenerator {
+    props;
+    authResources;
+    resourceGroupName = 'notifications';
+    constructor(props, authResources) {
+        this.props = props;
+        this.authResources = authResources;
+    }
+    generateContainerEntry = ({ scope, backendSecretResolver, }) => {
+        const { userPool, userPoolClient } = this.authResources.resources;
+        const region = Stack.of(scope).region;
+        return new AmplifyNotifications(scope, 'notifications', {
+            // Build the Cognito issuer / audience from THIS app's user pool so the
+            // HTTP API JWT authorizer only trusts tokens minted by this backend.
+            jwtIssuer: `https://cognito-idp.${region}.amazonaws.com/${userPool.userPoolId}`,
+            jwtAudience: [userPoolClient.userPoolClientId],
+            // `domainName` omitted => create-from-scratch (default); provided => attach.
+            domainName: this.props.domainName,
+            instanceAlias: this.props.instanceAlias,
+            expirationDays: this.props.expirationDays,
+            // Resolve the optional push-channel secret material (Amplify `secret()`) to
+            // deploy-time CFN tokens here — the construct stays framework-agnostic and
+            // receives only plain strings. Mirrors how `defineAuth` resolves external
+            // provider secrets in `translate_auth_props`.
+            apnsChannel: this.props.apns
+                ? {
+                    tokenKey: backendSecretResolver
+                        .resolveSecret(this.props.apns.keySecret)
+                        .unsafeUnwrap(),
+                    keyId: this.props.apns.keyId,
+                    teamId: this.props.apns.teamId,
+                    bundleId: this.props.apns.bundleId,
+                    sandbox: this.props.apns.sandbox,
+                }
+                : undefined,
+            fcmChannel: this.props.fcm
+                ? {
+                    serviceJson: backendSecretResolver
+                        .resolveSecret(this.props.fcm.credentialsSecret)
+                        .unsafeUnwrap(),
+                }
+                : undefined,
+        });
+    };
+}
+/**
+ * Singleton factory for the notifications backend, used in a Gen2
+ * `defineBackend` definition.
+ */
+class AmplifyNotificationsFactory {
+    props;
+    generator;
+    outputStored = false;
+    constructor(props) {
+        this.props = props;
+    }
+    getInstance = (getInstanceProps) => {
+        const { constructContainer, outputStorageStrategy } = getInstanceProps;
+        // Resolve THIS app's auth resource (Cognito user pool + client) so the JWT
+        // authorizer trusts only tokens issued by this backend.
+        const authResources = constructContainer
+            .getConstructFactory('AuthResources')
+            ?.getInstance(getInstanceProps);
+        if (!authResources) {
+            throw new AmplifyUserError('NotificationsMissingAuthError', {
+                message: 'defineNotifications requires an auth resource to be present in the backend.',
+                resolution: 'Add `auth` to your backend definition, e.g. `defineBackend({ auth, notifications })`.',
+            });
+        }
+        if (!this.generator) {
+            this.generator = new NotificationsGenerator(this.props, authResources);
+        }
+        const notifications = constructContainer.getOrCompute(this.generator);
+        // Surface the endpoint / region to the client via a custom backend output
+        // (written once, even though getInstance is a memoized singleton lookup).
+        if (!this.outputStored) {
+            this.storeOutput(outputStorageStrategy, notifications);
+            this.outputStored = true;
+        }
+        return notifications;
+    };
+    storeOutput = (outputStorageStrategy, notifications) => {
+        outputStorageStrategy.addBackendOutputEntry(customOutputKey, {
+            version: '1',
+            payload: {
+                // Serialized `Partial<ClientConfig>` — surfaced under `custom` in
+                // `amplify_outputs.json`, matching `backend.addOutput({ custom })`.
+                customOutputs: JSON.stringify({
+                    custom: {
+                        [OUTPUT_KEY]: {
+                            endpoint: notifications.apiEndpoint,
+                            region: notifications.stack.region,
+                        },
+                    },
+                }),
+            },
+        });
+    };
+}
+/**
+ * Include an Amazon Connect Customer Profiles-backed notifications resource in
+ * your Amplify backend. It registers the AmplifyProfile / AmplifyDevice object
+ * types, a least-privilege identify-user Lambda + a JWT-authorized HTTP API, and
+ * the push-delivery Lambda (invoked by a Connect Journey Custom-action) with a
+ * minimal AWS End User Messaging application. The invoke endpoint / region /
+ * domain name are surfaced under `custom.CustomerProfiles` in
+ * `amplify_outputs.json`.
+ *
+ * By DEFAULT (no `domainName`) it CREATES FROM SCRATCH: a brand-new Amazon
+ * Connect instance AND a brand-new Customer Profiles domain (generated, stable
+ * names) are provisioned and the object types are registered into that new
+ * domain — zero pre-existing Connect setup required, and Connect is fully hidden
+ * from the caller.
+ *
+ * Provide `domainName` to ATTACH to an EXISTING Customer Profiles domain — e.g.
+ * the domain Amazon Connect auto-creates for your instance — registering the
+ * object types into it (additive), without creating an instance or a domain.
+ *
+ * Optionally provide `apns` and/or `fcm` to enable the corresponding push
+ * channel on the created End User Messaging (Pinpoint) application. The
+ * sensitive key material (APNs `.p8`, FCM service-account JSON) is supplied via
+ * Amplify `secret()` and resolved at deploy time; non-secret identifiers are
+ * plain props. Omit them to leave the channels not configured (unchanged
+ * behavior).
+ * @example
+ * import { defineBackend } from '@aws-amplify/backend';
+ * import { defineNotifications } from '@aws-amplify/backend-notifications';
+ * import { auth } from './auth/resource';
+ * import { secret } from '@aws-amplify/backend';
+ *
+ * defineBackend({
+ *   auth,
+ *   // Zero-config: creates a Connect instance + Customer Profiles domain:
+ *   notifications: defineNotifications(),
+ *   // ...or attach to an existing domain and enable push channels:
+ *   // notifications: defineNotifications({
+ *   //   domainName: 'amazon-connect-amplify',
+ *   //   apns: {
+ *   //     keySecret: secret('APNS_SIGNING_KEY'),
+ *   //     keyId: 'ABC123DEFG',
+ *   //     teamId: 'DEF456GHIJ',
+ *   //     bundleId: 'com.example.app',
+ *   //   },
+ *   //   fcm: { credentialsSecret: secret('FCM_SERVICE_ACCOUNT_JSON') },
+ *   // }),
+ * });
+ */
+export const defineNotifications = (props = {}) => new AmplifyNotificationsFactory(props);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"factory.js","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AuthResources,\n  BackendOutputEntry,\n  BackendOutputStorageStrategy,\n  ConstructContainerEntryGenerator,\n  ConstructFactory,\n  ConstructFactoryGetInstanceProps,\n  GenerateContainerEntryProps,\n  ReferenceAuthResources,\n  ResourceProvider,\n} from '@aws-amplify/plugin-types';\nimport { Stack } from 'aws-cdk-lib';\nimport { customOutputKey } from '@aws-amplify/backend-output-schemas';\nimport { AmplifyUserError } from '@aws-amplify/platform-core';\nimport { AmplifyNotifications } from './construct.js';\nimport { NotificationsFactoryProps } from './types.js';\nimport { OUTPUT_KEY } from './constants.js';\n\n/**\n * Generates the {@link AmplifyNotifications} construct in the resolved stack,\n * wiring the HTTP API's JWT authorizer to the app's Cognito user pool.\n */\nclass NotificationsGenerator implements ConstructContainerEntryGenerator {\n  readonly resourceGroupName: string = 'notifications';\n\n  constructor(\n    private readonly props: NotificationsFactoryProps,\n    private readonly authResources: ResourceProvider<\n      AuthResources | ReferenceAuthResources\n    >,\n  ) {}\n\n  generateContainerEntry = ({\n    scope,\n    backendSecretResolver,\n  }: GenerateContainerEntryProps): AmplifyNotifications => {\n    const { userPool, userPoolClient } = this.authResources.resources;\n    const region = Stack.of(scope).region;\n\n    return new AmplifyNotifications(scope, 'notifications', {\n      // Build the Cognito issuer / audience from THIS app's user pool so the\n      // HTTP API JWT authorizer only trusts tokens minted by this backend.\n      jwtIssuer: `https://cognito-idp.${region}.amazonaws.com/${userPool.userPoolId}`,\n      jwtAudience: [userPoolClient.userPoolClientId],\n      // `domainName` omitted => create-from-scratch (default); provided => attach.\n      domainName: this.props.domainName,\n      instanceAlias: this.props.instanceAlias,\n      expirationDays: this.props.expirationDays,\n      // Resolve the optional push-channel secret material (Amplify `secret()`) to\n      // deploy-time CFN tokens here — the construct stays framework-agnostic and\n      // receives only plain strings. Mirrors how `defineAuth` resolves external\n      // provider secrets in `translate_auth_props`.\n      apnsChannel: this.props.apns\n        ? {\n            tokenKey: backendSecretResolver\n              .resolveSecret(this.props.apns.keySecret)\n              .unsafeUnwrap(),\n            keyId: this.props.apns.keyId,\n            teamId: this.props.apns.teamId,\n            bundleId: this.props.apns.bundleId,\n            sandbox: this.props.apns.sandbox,\n          }\n        : undefined,\n      fcmChannel: this.props.fcm\n        ? {\n            serviceJson: backendSecretResolver\n              .resolveSecret(this.props.fcm.credentialsSecret)\n              .unsafeUnwrap(),\n          }\n        : undefined,\n    });\n  };\n}\n\n/**\n * Singleton factory for the notifications backend, used in a Gen2\n * `defineBackend` definition.\n */\nclass AmplifyNotificationsFactory implements ConstructFactory<AmplifyNotifications> {\n  private generator: ConstructContainerEntryGenerator | undefined;\n  private outputStored = false;\n\n  constructor(private readonly props: NotificationsFactoryProps) {}\n\n  getInstance = (\n    getInstanceProps: ConstructFactoryGetInstanceProps,\n  ): AmplifyNotifications => {\n    const { constructContainer, outputStorageStrategy } = getInstanceProps;\n\n    // Resolve THIS app's auth resource (Cognito user pool + client) so the JWT\n    // authorizer trusts only tokens issued by this backend.\n    const authResources = constructContainer\n      .getConstructFactory<\n        ResourceProvider<AuthResources | ReferenceAuthResources>\n      >('AuthResources')\n      ?.getInstance(getInstanceProps);\n\n    if (!authResources) {\n      throw new AmplifyUserError('NotificationsMissingAuthError', {\n        message:\n          'defineNotifications requires an auth resource to be present in the backend.',\n        resolution:\n          'Add `auth` to your backend definition, e.g. `defineBackend({ auth, notifications })`.',\n      });\n    }\n\n    if (!this.generator) {\n      this.generator = new NotificationsGenerator(this.props, authResources);\n    }\n    const notifications = constructContainer.getOrCompute(\n      this.generator,\n    ) as AmplifyNotifications;\n\n    // Surface the endpoint / region to the client via a custom backend output\n    // (written once, even though getInstance is a memoized singleton lookup).\n    if (!this.outputStored) {\n      this.storeOutput(outputStorageStrategy, notifications);\n      this.outputStored = true;\n    }\n\n    return notifications;\n  };\n\n  private storeOutput = (\n    outputStorageStrategy: BackendOutputStorageStrategy<BackendOutputEntry>,\n    notifications: AmplifyNotifications,\n  ): void => {\n    outputStorageStrategy.addBackendOutputEntry(customOutputKey, {\n      version: '1',\n      payload: {\n        // Serialized `Partial<ClientConfig>` — surfaced under `custom` in\n        // `amplify_outputs.json`, matching `backend.addOutput({ custom })`.\n        customOutputs: JSON.stringify({\n          custom: {\n            [OUTPUT_KEY]: {\n              endpoint: notifications.apiEndpoint,\n              region: notifications.stack.region,\n            },\n          },\n        }),\n      },\n    });\n  };\n}\n\n/**\n * Include an Amazon Connect Customer Profiles-backed notifications resource in\n * your Amplify backend. It registers the AmplifyProfile / AmplifyDevice object\n * types, a least-privilege identify-user Lambda + a JWT-authorized HTTP API, and\n * the push-delivery Lambda (invoked by a Connect Journey Custom-action) with a\n * minimal AWS End User Messaging application. The invoke endpoint / region /\n * domain name are surfaced under `custom.CustomerProfiles` in\n * `amplify_outputs.json`.\n *\n * By DEFAULT (no `domainName`) it CREATES FROM SCRATCH: a brand-new Amazon\n * Connect instance AND a brand-new Customer Profiles domain (generated, stable\n * names) are provisioned and the object types are registered into that new\n * domain — zero pre-existing Connect setup required, and Connect is fully hidden\n * from the caller.\n *\n * Provide `domainName` to ATTACH to an EXISTING Customer Profiles domain — e.g.\n * the domain Amazon Connect auto-creates for your instance — registering the\n * object types into it (additive), without creating an instance or a domain.\n *\n * Optionally provide `apns` and/or `fcm` to enable the corresponding push\n * channel on the created End User Messaging (Pinpoint) application. The\n * sensitive key material (APNs `.p8`, FCM service-account JSON) is supplied via\n * Amplify `secret()` and resolved at deploy time; non-secret identifiers are\n * plain props. Omit them to leave the channels not configured (unchanged\n * behavior).\n * @example\n * import { defineBackend } from '@aws-amplify/backend';\n * import { defineNotifications } from '@aws-amplify/backend-notifications';\n * import { auth } from './auth/resource';\n * import { secret } from '@aws-amplify/backend';\n *\n * defineBackend({\n *   auth,\n *   // Zero-config: creates a Connect instance + Customer Profiles domain:\n *   notifications: defineNotifications(),\n *   // ...or attach to an existing domain and enable push channels:\n *   // notifications: defineNotifications({\n *   //   domainName: 'amazon-connect-amplify',\n *   //   apns: {\n *   //     keySecret: secret('APNS_SIGNING_KEY'),\n *   //     keyId: 'ABC123DEFG',\n *   //     teamId: 'DEF456GHIJ',\n *   //     bundleId: 'com.example.app',\n *   //   },\n *   //   fcm: { credentialsSecret: secret('FCM_SERVICE_ACCOUNT_JSON') },\n *   // }),\n * });\n */\nexport const defineNotifications = (\n  props: NotificationsFactoryProps = {},\n): ConstructFactory<AmplifyNotifications> =>\n  new AmplifyNotificationsFactory(props);\n"]}