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à.

Definizione di filtri avanzati per le sottoscrizioni in AWS AppSync

In AWS AppSync, è possibile definire e abilitare la logica aziendale per il filtraggio dei dati sul backend direttamente nei risolutori di sottoscrizione dell'API GraphQL utilizzando filtri che supportano operatori logici aggiuntivi. È possibile configurare questi filtri, a differenza degli argomenti di sottoscrizione definiti nella query di sottoscrizione nel client. Per ulteriori informazioni sull'utilizzo degli argomenti di sottoscrizione, vedereUtilizzo degli argomenti di sottoscrizione. Per un elenco di operatori, vedereAWS AppSync riferimento all'utilità del modello di mappatura del resolver.

Ai fini di questo documento, dividiamo il filtraggio dei dati in tempo reale nelle seguenti categorie:

Le sezioni seguenti spiegano come configurare i filtri di abbonamento avanzati e ne mostrano l'uso pratico.

Definizione delle sottoscrizioni nello schema GraphQL

Per utilizzare i filtri di abbonamento avanzati, definisci l'abbonamento nello schema GraphQL, quindi definisci il filtro avanzato utilizzando un'estensione di filtro. Per illustrare come funziona il filtro avanzato delle sottoscrizioni AWS AppSync, utilizzate il seguente schema GraphQL, che definisce un'API del sistema di gestione dei ticket, ad esempio:

type Ticket {
	id: ID
	createdAt: AWSDateTime
	content: String
	severity: Int
	priority: Priority
	category: String
	group: String
	status: String
	
}

type Mutation {
	createTicket(input: TicketInput): Ticket
}

type Query {
	getTicket(id: ID!): Ticket
}

type Subscription {
	onSpecialTicketCreated: Ticket @aws_subscribe(mutations: ["createTicket"])
	onGroupTicketCreated(group: String!): Ticket @aws_subscribe(mutations: ["createTicket"])
}



enum Priority {
	none
	lowest
	low
	medium
	high
	highest
}

input TicketInput {
	content: String
	severity: Int
	priority: Priority
	category: String
	group: String
	

Supponiamo di creare un'origine NONE dati per la tua API, quindi di collegare un resolver alla mutazione utilizzando questa fonte di dati. createTicket I tuoi gestori potrebbero assomigliare a questo:

import { util } from '@aws-appsync/utils';

export function request(ctx) {
	return {
		payload: {
			id: util.autoId(),
			createdAt: util.time.nowISO8601(),
			status: 'pending',
			...ctx.args.input,
		},
	};
}

export function response(ctx) {
	return ctx.result;
}

Per implementare il comportamento del filtro avanzato, è necessario utilizzare la extensions.setSubscriptionFilter() funzione per definire un'espressione di filtro valutata in base ai dati pubblicati da una mutazione GraphQL a cui potrebbero interessare i client sottoscritti. Per ulteriori informazioni sulle estensioni di filtro, vedere Estensioni. https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html

La sezione seguente spiega come utilizzare le estensioni di filtro per implementare filtri avanzati.

Creazione di filtri di abbonamento avanzati utilizzando le estensioni di filtro

I filtri avanzati sono scritti in JSON nel gestore delle risposte dei resolver dell'abbonamento. I filtri possono essere raggruppati in un elenco chiamato a. filterGroup I filtri vengono definiti utilizzando almeno una regola, ciascuno con campi, operatori e valori. Definiamo un nuovo resolver onSpecialTicketCreated che imposti un filtro avanzato. È possibile configurare più regole in un filtro che vengono valutate utilizzando la logica AND, mentre più filtri in un gruppo di filtri vengono valutati utilizzando la logica OR:

import { util, extensions } from '@aws-appsync/utils';

export function request(ctx) {
	// simplfy return null for the payload
	return { payload: null };
}

export function response(ctx) {
	const filter = {
		or: [
			{ severity: { ge: 7 }, priority: { in: ['high', 'medium'] } },
			{ category: { eq: 'security' }, group: { in: ['admin', 'operators'] } },
		],
	};
	extensions.setSubscriptionFilter(util.transform.toSubscriptionFilter(filter));

  // important: return null in the response
	return null;
}

In base ai filtri definiti nell'esempio precedente, i ticket importanti vengono automaticamente inviati ai client API sottoscritti se un ticket viene creato con:

O

I filtri definiti nel risolutore delle sottoscrizioni (filtro avanzato) hanno la precedenza sui filtri basati solo sugli argomenti della sottoscrizione (filtro di base). Per ulteriori informazioni sull'utilizzo degli argomenti di sottoscrizione, vedere Utilizzo degli argomenti di sottoscrizione). https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-data.html#using-subscription-arguments

Se un argomento è definito e richiesto nello schema GraphQL della sottoscrizione, il filtraggio in base all'argomento dato avviene solo se l'argomento è definito come regola nel metodo del resolver. extensions.setSubscriptionFilter() Tuttavia, se non ci sono metodi di extensions filtro nel risolutore di sottoscrizioni, gli argomenti definiti nel client vengono utilizzati solo per il filtraggio di base. Non è possibile utilizzare contemporaneamente il filtro di base e il filtro avanzato.

Puoi utilizzare la context variabile nella logica di estensione del filtro dell'abbonamento per accedere alle informazioni contestuali sulla richiesta. Ad esempio, quando utilizzi Amazon Cognito User Pools, OIDC o autorizzatori personalizzati Lambda per l'autorizzazione, puoi recuperare le informazioni sugli utenti nel momento in cui viene stabilito l'abbonamento. context.identity Puoi utilizzare queste informazioni per stabilire filtri in base all'identità dei tuoi utenti.

Supponiamo ora di voler implementare il comportamento di filtro avanzato peronGroupTicketCreated. L'onGroupTicketCreatedabbonamento richiede un group nome obbligatorio come argomento. Una volta creati, ai ticket viene assegnato automaticamente uno pending stato. Puoi impostare un filtro di abbonamento per ricevere solo i ticket appena creati che appartengono al gruppo fornito:

import { util, extensions } from '@aws-appsync/utils';

export function request(ctx) {
	// simplfy return null for the payload
	return { payload: null };
}

export function response(ctx) {
	const filter = { group: { eq: ctx.args.group }, status: { eq: 'pending' } };
	extensions.setSubscriptionFilter(util.transform.toSubscriptionFilter(filter));

	return null;
}

Quando i dati vengono pubblicati utilizzando una mutazione come nell'esempio seguente:

mutation CreateTicket {
  createTicket(input: {priority: medium, severity: 2, group: "aws"}) {
    id
    priority
    severity
    status
    group
    createdAt
  }
}

I clienti iscritti attendono che i dati vengano inviati automaticamente non WebSockets appena viene creato un ticket con la mutazione: createTicket

subscription OnGroup {
  onGroupTicketCreated(group: "aws") {
    category
    status
    severity
    priority
    id
    group
    createdAt
    content
  }
}

I client possono essere abbonati senza argomenti perché la logica di filtraggio è implementata nel AWS AppSync servizio con un filtro avanzato, che semplifica il codice del cliente. I client ricevono i dati solo se vengono soddisfatti i criteri di filtro definiti.

Definizione di filtri avanzati per i campi dello schema annidati

È possibile utilizzare il filtro avanzato delle sottoscrizioni per filtrare i campi dello schema annidati. Supponiamo di aver modificato lo schema della sezione precedente per includere i tipi di posizione e indirizzo:

type Ticket {
	id: ID
	createdAt: AWSDateTime
	content: String
	severity: Int
	priority: Priority
	category: String
	group: String
	status: String
	location: ProblemLocation
}

type Mutation {
	createTicket(input: TicketInput): Ticket
}

type Query {
	getTicket(id: ID!): Ticket
}

type Subscription {
	onSpecialTicketCreated: Ticket @aws_subscribe(mutations: ["createTicket"])
	onGroupTicketCreated(group: String!): Ticket @aws_subscribe(mutations: ["createTicket"])
}

type ProblemLocation {
	address: Address
}

type Address {
	country: String
}

enum Priority {
	none
	lowest
	low
	medium
	high
	highest
}

input TicketInput {
	content: String
	severity: Int
	priority: Priority
	category: String
	group: String
	location: AWSJSON

Con questo schema, puoi usare un . separatore per rappresentare l'annidamento. L'esempio seguente aggiunge una regola di filtro per un campo dello schema annidato in. location.address.country L'abbonamento verrà attivato se l'indirizzo del ticket è impostato su: USA

import { util, extensions } from '@aws-appsync/utils';

export const request = (ctx) => ({ payload: null });

export function response(ctx) {
	const filter = {
		or: [
			{ severity: { ge: 7 }, priority: { in: ['high', 'medium'] } },
			{ category: { eq: 'security' }, group: { in: ['admin', 'operators'] } },
			{ 'location.address.country': { eq: 'USA' } },
		],
	};
	extensions.setSubscriptionFilter(util.transform.toSubscriptionFilter(filter));
	return null;
}

Nell'esempio precedente, location rappresenta il livello di nidificazione uno, address rappresenta il livello di nidificazione due e country rappresenta il livello di nidificazione tre, tutti separati dal separatore. .

Puoi testare questo abbonamento utilizzando la mutazione: createTicket

mutation CreateTicketInUSA {
  createTicket(input: {location: "{\"address\":{\"country\":\"USA\"}}"}) {
    category
    content
    createdAt
    group
    id
    location {
      address {
        country
      }
    }
    priority
    severity
    status
  }
}

Definizione di filtri avanzati dal client

È possibile utilizzare il filtro di base in GraphQL con argomenti di sottoscrizione. Il client che effettua la chiamata nella query di sottoscrizione definisce i valori degli argomenti. Quando i filtri avanzati sono abilitati in un risolutore di AWS AppSync sottoscrizioni con il extensions filtro, i filtri di backend definiti nel resolver hanno la precedenza e la priorità.

Configura filtri avanzati dinamici definiti dal cliente utilizzando un argomento nell'abbonamento. filter Quando configuri questi filtri, devi aggiornare lo schema GraphQL in modo che rifletta il nuovo argomento:

...
type Subscription {
    onSpecialTicketCreated(filter: String): Ticket
        @aws_subscribe(mutations: ["createTicket"])
}
...

Il cliente può quindi inviare una richiesta di iscrizione come nell'esempio seguente:

subscription onSpecialTicketCreated($filter: String) {
     onSpecialTicketCreated(filter: $filter) {
        id
        group
        description
        priority
        severity
     }
 }

È possibile configurare la variabile di query come nell'esempio seguente:

{"filter" : "{\"severity\":{\"le\":2}}"}

L'utilità util.transform.toSubscriptionFilter() resolver può essere implementata nel modello di mappatura delle risposte dell'abbonamento per applicare il filtro definito nell'argomento dell'abbonamento per ogni client:

import { util, extensions } from '@aws-appsync/utils';

export function request(ctx) {
	// simplfy return null for the payload
	return { payload: null };
}

export function response(ctx) {
	const filter = ctx.args.filter;
	extensions.setSubscriptionFilter(util.transform.toSubscriptionFilter(filter));
	return null;
}

Con questa strategia, i clienti possono definire i propri filtri che utilizzano una logica di filtraggio avanzata e operatori aggiuntivi. I filtri vengono assegnati quando un determinato client richiama la richiesta di sottoscrizione in una connessione sicura WebSocket . Per ulteriori informazioni sull'utilità di trasformazione per un filtro avanzato, incluso il formato del payload della variabile di filter query, vedi JavaScript la panoramica dei resolver.

Restrizioni di filtraggio avanzate aggiuntive

Di seguito sono riportati diversi casi d'uso in cui vengono applicate ulteriori restrizioni ai filtri avanzati: