Merge remote-tracking branch 'upstream/main' into add-auth-example-entra-id-saml

Author: josefaidt

src/directory/directory.mjs

@@ -390,6 +390,9 @@ export const directory = {
                 {
                   path: 'src/pages/[platform]/build-a-backend/functions/streaming-logs/index.mdx'
                 },
+                {
+                  path: 'src/pages/[platform]/build-a-backend/functions/add-lambda-layers/index.mdx'
+                },
                 {
                   path: 'src/pages/[platform]/build-a-backend/functions/grant-access-to-other-resources/index.mdx'
                 },
@@ -685,6 +688,9 @@ export const directory = {
                 {
                   path: 'src/pages/[platform]/build-a-backend/add-aws-services/custom-resources/index.mdx'
                 },
+                {
+                  path: 'src/pages/[platform]/build-a-backend/add-aws-services/tagging-resources/index.mdx'
+                },
                 {
                   path: 'src/pages/[platform]/build-a-backend/add-aws-services/overriding-resources/index.mdx'
                 }

src/fragments/start/getting-started/reactnative/setup.mdx

@@ -1,6 +1,6 @@
 ## Create a new project
 
-To get started, initialize a new React Native project.
+To get started, initialize a new React Native project for Android or iOS.
 
 <BlockSwitcher>
 <Block name="Expo CLI">

src/pages/[platform]/build-a-backend/add-aws-services/overriding-resources/index.mdx

@@ -129,28 +129,4 @@ The `auth.resources.cfnResources.cfnUserPool` property in the above example dire
 
 This is different from `auth.resources.userPool` in the first example, which is an [L2 CDK construct](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html#constructs_using). These are constructs that provide a convenient interface around several related L1 constructs.
 
-## Example - Add tags to resources
-
-```ts title="amplify/backend.ts"
-import { defineBackend } from '@aws-amplify/backend';
-import { auth } from './auth/resource';
-import { data } from './data/resource';
-
-const backend = defineBackend({
-  auth,
-  data
-});
-
-backend.data.resources.cfnResources.cfnGraphqlApi.addPropertyOverride('Tags', [
-  {
-    Key: 'graphqlapi-tag-1',
-    Value: 'graphql-tag-value-1'
-  },
-  {
-    Key: 'graphqlapi-tag-2',
-    Value: 'graphql-tag-value-2'
-  }
-]);
-```
-
 For situations where you need even more customization of your app backend, see the documentation on [custom resources](/[platform]/build-a-backend/add-aws-services/custom-resources).

src/pages/[platform]/build-a-backend/add-aws-services/tagging-resources/index.mdx

@@ -0,0 +1,67 @@
+import { getCustomStaticPath } from '@/utils/getCustomStaticPath';
+
+export const meta = {
+  title: 'Tagging resources',
+  description: 'Decorate resources with tags for categorization.',
+  platforms: [
+    'android',
+    'angular',
+    'flutter',
+    'javascript',
+    'nextjs',
+    'react',
+    'react-native',
+    'swift',
+    'vue'
+  ],
+};
+
+export async function getStaticPaths() {
+  return getCustomStaticPath(meta.platforms);
+}
+
+export function getStaticProps(context) {
+  return {
+    props: {
+      platform: context.params.platform,
+      meta
+    }
+  };
+}
+
+Tags are a key-value pair that are applied to AWS resources to hold metadata. Tags are often used to decorate resources with metadata that helps categorize resources for billing or viewing purposes. Learn more about tags by visiting the [AWS documentation for best practices for tagging resources](https://docs.aws.amazon.com/whitepapers/latest/tagging-best-practices/what-are-tags.html).
+
+Amplify applies the following tags by default:
+
+| Deployment type | Tag key                   | Tag value                |
+|-----------------|---------------------------|--------------------------|
+| sandbox         | `created-by`              | `amplify`                |
+| sandbox         | `amplify:deployment-type` | `sandbox`                |
+| branch          | `created-by`              | `amplify`                |
+| branch          | `amplify:deployment-type` | `branch`                 |
+| branch          | `amplify:app-id`          | `<your-amplify-app-id>`  |
+| branch          | `amplify:branch-name`     | `<your-git-branch-name>` |
+
+In your Amplify backend you can use the [`Tags`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Tags.html) class from the [AWS Cloud Development Kit (CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) to apply tags at the root level, which then cascades to child resources.
+
+```ts title="amplify/backend.ts"
+import { Tags } from 'aws-cdk-lib';
+import { defineBackend } from '@aws-amplify/backend';
+import { auth } from './auth/resource';
+import { data } from './data/resource';
+
+/**
+ * @see https://docs.amplify.aws/react/build-a-backend/ to add storage, functions, and more
+ */
+const backend = defineBackend({
+  auth,
+  data
+});
+
+const tags = Tags.of(backend.stack);
+// add a new tag
+tags.add('my-key', 'my-value');
+// remove tags
+tags.remove('my-key');
+```
+

src/pages/[platform]/build-a-backend/auth/manage-users/manage-passwords/index.mdx

@@ -512,27 +512,35 @@ export const auth = defineAuth({
 
 ## Override default password policy
 
-You can customize the password format acceptable by your auth backend. By default your password policy is set to the following:
+By default your password policy is set to the following:
 
 - `MinLength`: 8 characters
 - `requireLowercase`: true
 - `requireUppercase`: true
-- `requireDigits`: true
+- `requireNumbers`: true
+- `requireSymbols`: true
 - `tempPasswordValidity`: 3 days
 
+You can customize the password format acceptable by your auth resource by modifying the underlying `cfnUserPool` resource:
+
 ```ts title="amplify/backend.ts"
-// amplify/backend.ts
 import { defineBackend } from '@aws-amplify/backend';
 import { auth } from './auth/resource';
-import { data } from './data/resource';
 
 const backend = defineBackend({
   auth,
-  data
 });
-
-// extract L1 UserPool construct
+// extract L1 CfnUserPool resources
 const { cfnUserPool } = backend.auth.resources.cfnResources;
-// from the CDK use `addPropertyOverride` to modify properties directly
-cfnUserPool.addPropertyOverride('Policies.PasswordPolicy.MinimumLength', 32);
+// modify cfnUserPool policies directly
+cfnUserPool.policies = {
+  passwordPolicy: {
+    minimumLength: 32,
+    requireLowercase: true,
+    requireNumbers: true,
+    requireSymbols: true,
+    requireUppercase: true,
+    temporaryPasswordValidityDays: 20,
+  },
+};
 ```

src/pages/[platform]/build-a-backend/auth/moving-to-production/index.mdx

@@ -44,33 +44,50 @@ To get started with Amazon SES in production, you must first [request production
 
 After you have configured your account for production access and have verified your _sender_ email, you can configure your Cognito user pool to send emails using the verified sender:
 
-```ts title="amplify/backend.ts"
-import { Stack } from "aws-cdk-lib/core"
-import { EmailIdentity } from "aws-cdk-lib/aws-ses"
-import { defineBackend } from "@aws-amplify/backend"
-import { auth } from "./auth/resource"
-
-const backend = defineBackend({
-  auth,
+```ts title="amplify/auth/resource.ts"
+import { defineAuth } from "@aws-amplify/backend"
+
+/**
+ * Define and configure your auth resource
+ * @see https://docs.amplify.aws/react/build-a-backend/auth
+ */
+export const auth = defineAuth({
+  loginWith: {
+    email: true,
+  },
+  senders: {
+    email: {
+      // configure using the email registered and verified in Amazon SES
+      fromEmail: "[email protected]",
+    },
+  },
 })
-
-const { cfnUserPool } = backend.auth.resources.cfnResources
-const authStack = Stack.of(cfnUserPool)
-
-const email = EmailIdentity.fromEmailIdentityName(
-  authStack,
-  "EmailIdentity",
-  // your email configured for use in SES
-  process.env.EMAIL
-)
-
-cfnUserPool.emailConfiguration = {
-  emailSendingAccount: "DEVELOPER",
-  sourceArn: email.emailIdentityArn,
-}
 ```
 
-Now when emails are sent on new user sign-ups, password resets, etc., the sending account will be your verified email.
+Now when emails are sent on new user sign-ups, password resets, etc., the sending account will be your verified email! To customize further, you can change the display name of the sender, or optionally apply a custom address for your users to reply.
+
+```ts title="amplify/auth/resource.ts"
+import { defineAuth } from "@aws-amplify/backend"
+
+/**
+ * Define and configure your auth resource
+ * @see https://docs.amplify.aws/react/build-a-backend/auth
+ */
+export const auth = defineAuth({
+  loginWith: {
+    email: true,
+  },
+  senders: {
+    email: {
+      fromEmail: "[email protected]",
+      // highlight-start
+      fromName: "MyApp",
+      replyTo: "[email protected]"
+      // highlight-end
+    },
+  },
+})
+```
 
 ## SMS
 

src/pages/[platform]/build-a-backend/functions/add-lambda-layers/index.mdx

@@ -0,0 +1,61 @@
+import { getCustomStaticPath } from '@/utils/getCustomStaticPath';
+
+export const meta = {
+  title: 'Lambda Layers',
+  description:
+    'Learn how to add layers to your function',
+  platforms: [
+    'android',
+    'angular',
+    'flutter',
+    'javascript',
+    'nextjs',
+    'react',
+    'react-native',
+    'swift',
+    'vue'
+  ]
+};
+
+export function getStaticPaths() {
+  return getCustomStaticPath(meta.platforms);
+}
+
+export function getStaticProps() {
+  return {
+    props: {
+      meta
+    }
+  };
+}
+
+Amplify offers the ability to add layers to your Functions which contain your library dependencies. To get started, specify the `layers` property in `defineFunction`:
+
+```ts title="amplify/functions/my-function/resource.ts"
+import { defineFunction } from "@aws-amplify/backend";
+
+export const myFunction = defineFunction({
+  name: "my-function",
+  layers: {
+   "@aws-lambda-powertools/logger":
+      "arn:aws:lambda:us-east-1:094274105915:layer:AWSLambdaPowertoolsTypeScriptV2:12",
+  },
+});
+```
+
+The Lambda layer is represented by an object of key/value pairs where the key is the module name that is exported from your layer and the value is the ARN of the layer. The key (module name) is used to externalize the module dependency so it doesn't get bundled with your lambda function. A maximum of 5 layers can be attached to a function, and they must be in the same region as the function.
+
+Then use the locally installed module in the function handler:
+```ts title="amplify/functions/my-function/handler.ts"
+import { Logger } from "@aws-lambda-powertools/logger";
+import type { Handler } from "aws-lambda";
+
+const logger = new Logger({ serviceName: "serverlessAirline" });
+
+export const handler: Handler = async (event, context) => {
+  logger.info("Hello World");
+};
+```
+
+For further information on creating and managing your layers refer to [AWS documentation for Lambda layers](https://docs.aws.amazon.com/lambda/latest/dg/chapter-layers.html)
+