Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Utilizzo di resolver locali in AWS AppSync
<a name="tutorial-local-resolvers"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html)

AWS AppSync consente di utilizzare fonti di dati supportate (AWS Lambda Amazon DynamoDB o OpenSearch Amazon Service) per eseguire varie operazioni. In alcuni scenari, tuttavia, una chiamata a un'origine dati supportata può non essere necessaria.

È in queste situazioni che il resolver locale risulta utile. Invece di chiamare un'origine dati remota, il resolver locale **inoltra** semplicemente il risultato del modello di mappatura della richiesta al modello di mappatura della risposta. La risoluzione del campo rimarrà in AWS AppSync.

I resolver locali sono utili per diversi casi d'uso. Quello più comune è la pubblicazione di notifiche senza attivare una chiamata a un'origine dati. Per dimostrare questo caso d'uso creeremo un'applicazione di paging in cui gli utenti possono inviarsi messaggi. In questo esempio vengono usate le *sottoscrizioni*. Quindi, se non hai familiarità con le *sottoscrizioni*, puoi seguire il tutorial [Dati in tempo reale](aws-appsync-real-time-data.md).

## Creare l'applicazione di paging
<a name="create-the-paging-application"></a>

In questa applicazione di paging, i client possono iscriversi a una casella di posta e inviare pagine ad altri client. Ogni pagina include un messaggio. Lo schema è il seguente:

```
schema {
    query: Query
    mutation: Mutation
    subscription: Subscription
}

type Subscription {
    inbox(to: String!): Page
    @aws_subscribe(mutations: ["page"])
}

type Mutation {
    page(body: String!, to: String!): Page!
}

type Page {
    from: String
    to: String!
    body: String!
    sentAt: String!
}

type Query {
    me: String
}
```

Colleghiamo ora un resolver al campo `Mutation.page`. Nel riquadro **Schema**, fai clic su *Attach Resolver (Collega resolver)* accanto alla definizione del campo nel riquadro destro. Crea una nuova fonte di dati di tipo *Nessuno* e assegnale un nome. *PageDataSource*

Per il modello di mappatura della richiesta immetti:

```
{
  "version": "2017-02-28",
  "payload": {
    "body": $util.toJson($context.arguments.body),
    "from": $util.toJson($context.identity.username),
    "to":  $util.toJson($context.arguments.to),
    "sentAt": "$util.time.nowISO8601()"
  }
}
```

E per il modello di mappatura della risposta, seleziona l'impostazione predefinita *Forward the result (Inoltra il risultato)*. Salva il resolver. L'applicazione è pronta per iniziare a inviare messaggi.

## Inviare e iscriversi alle pagine
<a name="send-and-subscribe-to-pages"></a>

Perché i client possano ricevere le pagine, devono prima iscriversi a una casella di posta.

Nel riquadro **Queries (Query)** eseguiamo la sottoscrizione `inbox`:

```
subscription Inbox {
    inbox(to: "Nadia") {
        body
        to
        from
        sentAt
    }
}
```

 *Nadia* riceverà le pagine ogni volta che la mutazione `Mutation.page` viene richiamata. La mutazione viene richiamata tramite la relativa esecuzione:

```
mutation Page {
    page(to: "Nadia", body: "Hello, World!") {
        body
        to
        from
        sentAt
    }
}
```

Abbiamo appena dimostrato l'uso dei resolver locali, inviando una pagina e ricevendola senza uscire da AWS AppSync.