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

Author: josefaidt

src/pages/[platform]/build-a-backend/add-aws-services/logging/set-up-logging/index.mdx

@@ -113,11 +113,11 @@ The `<log-group-name>` and `<region>` configured in the CDK construct will be us
 - `<amplify-authenticated-role-name>` and `<amplify-unauthenticated-role-name>` are Amplify roles created as part of Amplify Auth configuration via Amplify CLI.
 
 ```ts
+import * as path from "node:path"
 import * as cdk from "aws-cdk-lib"
-import { Construct } from "constructs"
 import * as logs from "aws-cdk-lib/aws-logs"
-import * as path from "path"
 import * as iam from "aws-cdk-lib/aws-iam"
+import { Construct } from "constructs"
 
 export class RemoteLoggingConstraintsConstruct extends Construct {
   constructor(scope: Construct, id: string, props: RemoteLoggingConstraintProps) {

src/pages/[platform]/build-a-backend/add-aws-services/predictions/set-up-predictions/index.mdx

@@ -25,8 +25,6 @@ export function getStaticProps() {
   };
 }
 
-### Set up the backend
-
 To enable Predictions we need to set up the appropriate IAM policy for Roles in your Cognito Identity Pool in order to use an appropriate feature. Additionally, we need to use the ```addOutput``` method to patch the custom Predictions resource to the expected output configuration.
 
 <Callout informational>
@@ -38,11 +36,9 @@ To learn more, check the docs of [Amazon Translate](https://docs.aws.amazon.com/
 
 
 ```ts title="amplify/backend.ts"
-
+import { PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { defineBackend } from "@aws-amplify/backend";
 import { auth } from "./auth/resource";
-import { Stack } from "aws-cdk-lib";
-import { PolicyStatement } from "aws-cdk-lib/aws-iam";
 
 const backend = defineBackend({
   auth,
@@ -88,24 +84,21 @@ backend.addOutput({
             targetLanguage: "es",
           },
           proxy: false,
-          region: Stack.of(backend.auth.resources.unauthenticatedUserIamRole)
-            .region,
+          region: backend.auth.stack.region,
         },
         speechGenerator: {
           defaults: {
             voiceId: "Ivy",
           },
           proxy: false,
-          region: Stack.of(backend.auth.resources.unauthenticatedUserIamRole)
-            .region,
+          region: backend.auth.stack.region,
         },
         transcription: {
           defaults: {
             language: "en-US",
           },
           proxy: false,
-          region: Stack.of(backend.auth.resources.unauthenticatedUserIamRole)
-            .region,
+          region: backend.auth.stack.region,
         },
       },
       identify: {
@@ -116,24 +109,21 @@ backend.addOutput({
           },
           celebrityDetectionEnabled: true,
           proxy: false,
-          region: Stack.of(backend.auth.resources.unauthenticatedUserIamRole)
-            .region,
+          region: backend.auth.stack.region,
         },
         identifyLabels: {
           defaults: {
             type: "ALL",
           },
           proxy: false,
-          region: Stack.of(backend.auth.resources.unauthenticatedUserIamRole)
-            .region,
+          region: backend.auth.stack.region,
         },
         identifyText: {
           defaults: {
             format: "ALL",
           },
           proxy: false,
-          region: Stack.of(backend.auth.resources.unauthenticatedUserIamRole)
-            .region,
+          region: backend.auth.stack.region,
         },
       },
       interpret: {
@@ -142,17 +132,14 @@ backend.addOutput({
             type: "ALL",
           },
           proxy: false,
-          region: Stack.of(backend.auth.resources.unauthenticatedUserIamRole)
-            .region,
+          region: backend.auth.stack.region,
         },
       },
     },
   },
 });
-
-
-
 ```
+
 ## Install Amplify Libraries
 
 To install the Amplify library to use predictions features, run the following commands in your project's root folder:

src/pages/[platform]/build-a-backend/data/connect-to-existing-data-sources/connect-external-ddb-table/index.mdx

@@ -481,19 +481,18 @@ To delete your external DynamoDB table, you can navigate to the AppSync console
 [Reference](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem) - The `GetItem` request lets you tell the AWS AppSync DynamoDB function to make a `GetItem` request to DynamoDB, and enables you to specify:
 
 - The key of the item in DynamoDB
-
 - Whether to use a consistent read or not
 
 **Example:**
 
 ```js
 export function request(ctx) {
-  const {foo, bar} = ctx.args
+  const { foo, bar } = ctx.args;
   return {
-    operation : "GetItem",
-    key : util.dynamodb.toMapValues({foo, bar}),
-    consistentRead : true
-  }
+    operation: 'GetItem',
+    key: util.dynamodb.toMapValues({ foo, bar }),
+    consistentRead: true
+  };
 }
 ```
 
@@ -502,21 +501,20 @@ export function request(ctx) {
 [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem) - The `PutItem` request mapping document lets you tell the AWS AppSync DynamoDB function to make a `PutItem` request to DynamoDB, and enables you to specify the following:
 
 - The key of the item in DynamoDB
-
 - The full contents of the item (composed of key and attributeValues)
-
 - Conditions for the operation to succeed
 
 **Example:**
 
 ```js
 import { util } from '@aws-appsync/utils';
+
 export function request(ctx) {
-  const { foo, bar, ...values} = ctx.args
+  const { foo, bar, ...values } = ctx.args;
   return {
     operation: 'PutItem',
-    key: util.dynamodb.toMapValues({foo, bar}),
-    attributeValues: util.dynamodb.toMapValues(values),
+    key: util.dynamodb.toMapValues({ foo, bar }),
+    attributeValues: util.dynamodb.toMapValues(values)
   };
 }
 ```
@@ -526,15 +524,14 @@ export function request(ctx) {
 [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem) - The `UpdateItem` request enables you to tell the AWS AppSync DynamoDB function to make a `UpdateItem` request to DynamoDB and allows you to specify the following:
 
 - The key of the item in DynamoDB
-
 - An update expression describing how to update the item in DynamoDB
-
 - Conditions for the operation to succeed
 
 **Example:**
 
 ```js
 import { util } from '@aws-appsync/utils';
+
 export function request(ctx) {
   const { id } = ctx.args;
   return {
@@ -543,8 +540,8 @@ export function request(ctx) {
     update: {
       expression: 'ADD #voteField :plusOne, version :plusOne',
       expressionNames: { '#voteField': 'upvotes' },
-      expressionValues: { ':plusOne': { N: 1 } },
-    },
+      expressionValues: { ':plusOne': { N: 1 } }
+    }
   };
 }
 ```
@@ -554,17 +551,17 @@ export function request(ctx) {
 [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem) - The `DeleteItem` request lets you tell the AWS AppSync DynamoDB function to make a `DeleteItem` request to DynamoDB, and enables you to specify the following:
 
 - The key of the item in DynamoDB
-
 - Conditions for the operation to succeed
 
 **Example:**
 
 ```js
 import { util } from '@aws-appsync/utils';
+
 export function request(ctx) {
   return {
     operation: 'DeleteItem',
-    key: util.dynamodb.toMapValues({ id: ctx.args.id }),
+    key: util.dynamodb.toMapValues({ id: ctx.args.id })
   };
 }
 ```
@@ -574,17 +571,11 @@ export function request(ctx) {
 [Query](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-query) - The Query request object lets you tell the AWS AppSync DynamoDB resolver to make a Query request to DynamoDB, and enables you to specify the following:
 
 - Key expression
-
 - Which index to use
-
 - Any additional filter
-
 - How many items to return
-
 - Whether to use consistent reads
-
 - query direction (forward or backward)
-
 - Pagination token
 
 **Example:**
@@ -598,9 +589,9 @@ export function request(ctx) {
     operation: 'Query',
     query: {
       expression: 'ownerId = :ownerId',
-      expressionValues: util.dynamodb.toMapValues({ ':ownerId': owner }),
+      expressionValues: util.dynamodb.toMapValues({ ':ownerId': owner })
     },
-    index: 'owner-index',
+    index: 'owner-index'
   };
 }
 ```
@@ -609,15 +600,10 @@ export function request(ctx) {
 [Scan](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) - The `Scan` request lets you tell the AWS AppSync DynamoDB function to make a `Scan` request to DynamoDB, and enables you to specify the following:
 
 - A filter to exclude results
-
 - Which index to use
-
 - How many items to return
-
 - Whether to use consistent reads
-
 - Pagination token
-
 - Parallel scans
 
 **Example:**

src/pages/[platform]/build-a-backend/data/custom-business-logic/connect-amazon-rekognition/index.mdx

@@ -75,12 +75,10 @@ export const storage = defineStorage({
 To use the Amazon Rekognition service, you need to add Amazon Rekognition as an HTTP Data Source and configure the proper IAM policy for Lambda to effectively utilize the desired feature and grant permission to access the storage. In this case, you can add the `rekognition:DetectText` and `rekognition:DetectLabels` actions to the policy. Update the `amplify/backend.ts` file as shown below.
 
  ```ts title= "amplify/backend.ts"
-
+import { PolicyStatement } from 'aws-cdk-lib/aws-iam';
 import { defineBackend } from '@aws-amplify/backend';
 import { auth } from './auth/resource';
 import { data } from './data/resource';
-import { Stack } from 'aws-cdk-lib';
-import { PolicyStatement } from 'aws-cdk-lib/aws-iam';
 import { storage } from './storage/resource';
 
 const backend = defineBackend({
@@ -89,19 +87,17 @@ const backend = defineBackend({
   storage
 });
 
-const dataStack = Stack.of(backend.data)
-
 // Set environment variables for the S3 Bucket name
 backend.data.resources.cfnResources.cfnGraphqlApi.environmentVariables = {
   S3_BUCKET_NAME: backend.storage.resources.bucket.bucketName,
 };
 
 const rekognitionDataSource = backend.data.addHttpDataSource(
   "RekognitionDataSource",
-  `https://rekognition.${dataStack.region}.amazonaws.com`,
+  `https://rekognition.${backend.data.stack.region}.amazonaws.com`,
   {
     authorizationConfig: {
-      signingRegion: dataStack.region,
+      signingRegion: backend.data.stack.region,
       signingServiceName: "rekognition",
     },
   }

src/pages/[platform]/build-a-backend/data/custom-business-logic/connect-amazon-translate/index.mdx

@@ -60,24 +60,21 @@ npm add @aws-sdk/client-translate
 
  ```ts title="amplify/backend.ts"
 import { defineBackend } from '@aws-amplify/backend';
-import { auth } from './auth/resource';
-import { data } from "./data/resource";
-import { Stack } from 'aws-cdk-lib';
 import { PolicyStatement } from 'aws-cdk-lib/aws-iam';
+import { auth } from './auth/resource';
+import { data } from './data/resource';
 
 const backend = defineBackend({
   auth,
   data
 });
 
-const dataStack = Stack.of(backend.data)
-
 const translateDataSource = backend.data.addHttpDataSource(
   "TranslateDataSource",
-  `https://translate.${dataStack.region}.amazonaws.com`,
+  `https://translate.${backend.data.stack.region}.amazonaws.com`,
   {
     authorizationConfig: {
-      signingRegion: dataStack.region,
+      signingRegion: backend.data.stack.region,
       signingServiceName: "translate",
     },
   }