Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Referensi tipe GraphQL
<a name="type-reference"></a>

Jenis skalar di GraphQL mewakili nilai daun primitif dalam skema GraphQL. Ini adalah tipe data paling dasar yang menyelesaikan ke satu nilai. Tidak seperti tipe objek, tipe skalar tidak dapat memiliki sub-bidang. GraphQL dilengkapi dengan satu set tipe skalar default: 
+ **Int**: Bilangan bulat 32-bit yang ditandatangani 
+ **Float: Nilai floating-point** presisi ganda yang ditandatangani 
+ **String**: Urutan karakter UTF-8 
+ **Boolean**: Nilai benar atau salah
+ **ID**: Pengidentifikasi unik, sering digunakan untuk refetch objek atau sebagai kunci untuk cache

Jenis skalar ini berfungsi sebagai blok bangunan untuk jenis yang lebih kompleks dalam skema Anda. Mereka digunakan untuk mendefinisikan bidang yang berisi nilai-nilai tunggal yang sederhana. Selain skalar bawaan ini, AWS AppSync memberi Anda skalar tambahan untuk kasus penggunaan yang berbeda. 

Antarmuka dan Serikat di GraphQL adalah tipe abstrak yang memungkinkan desain skema yang fleksibel dan dapat diperluas. Mereka menyediakan mekanisme untuk mengelompokkan tipe terkait dan memungkinkan kueri polimorfik. Antarmuka di GraphQL adalah tipe abstrak yang mendefinisikan sekumpulan bidang yang harus disertakan tipe untuk mengimplementasikan antarmuka. Ini berfungsi sebagai kontrak untuk objek dengan menentukan seperangkat bidang umum yang harus dimiliki tipe implementasi. Antarmuka berguna ketika Anda ingin mengembalikan objek atau bidang yang dapat terdiri dari beberapa jenis berbeda, tetapi masih memiliki beberapa bidang yang dijamin. Sebaliknya, Union di GraphQL mewakili tipe yang bisa menjadi salah satu dari beberapa tipe objek, tetapi tidak mendefinisikan bidang umum di antara tipe tersebut. Serikat pekerja sangat membantu ketika Anda perlu mengembalikan bidang yang dapat terdiri dari beberapa jenis, dan jenis ini tidak selalu berbagi bidang umum. Baik Antarmuka dan Serikat sangat berguna dalam skenario di mana bidang mungkin mengembalikan berbagai jenis data, memungkinkan klien untuk menanyakan bidang tertentu berdasarkan jenis yang dikembalikan. 

Bagian ini digunakan sebagai referensi untuk jenis skema.

**Topik**
+ [Jenis skalar di GraphQL](https://docs.aws.amazon.com/appsync/latest/devguide/scalars.html)
+ [Antarmuka dan serikat pekerja di GraphQL](https://docs.aws.amazon.com/appsync/latest/devguide/interfaces-and-unions.html)

# Jenis skalar di GraphQL
<a name="scalars"></a>

Jenis objek GraphQL memiliki nama dan bidang, dan bidang tersebut dapat memiliki sub-bidang. Pada akhirnya, bidang tipe objek harus diselesaikan ke jenis *skalar*, yang mewakili daun kueri. Untuk informasi selengkapnya tentang jenis objek dan skalar, lihat [Skema dan tipe](https://graphql.org/learn/schema/) di situs web GraphQL.

Selain set default skalar GraphQL AWS AppSync , Anda juga dapat menggunakan skalar yang ditentukan layanan **yang dimulai dengan** awalan. *AWS* AWS AppSync tidak mendukung pembuatan skalar yang **ditentukan pengguna** (khusus). Anda harus menggunakan default atau *AWS*skalar. 

Anda tidak dapat menggunakan *AWS*sebagai awalan untuk jenis objek kustom.

Bagian berikut adalah referensi untuk pengetikan skema.

## Skalar default
<a name="graph-ql-base-scalars"></a>

GraphQL mendefinisikan skalar default berikut:

### Daftar skalar default
<a name="graph-ql-base-scalars-list"></a>

`ID`  
Pengidentifikasi unik untuk suatu objek. Skalar ini diserialkan seperti a `String` tetapi tidak dimaksudkan untuk dapat dibaca manusia.

`String`  
Urutan karakter UTF-8.

`Int`  
Nilai integer antara - (2 31) dan 2 31 -1.

`Float`  
Nilai floating point IEEE 754.

`Boolean`  
Nilai Boolean, baik `true` ataupun `false`.

## AWS AppSync skalar
<a name="graph-ql-aws-appsync-scalars"></a>

AWS AppSync mendefinisikan skalar berikut:

### AWS AppSync daftar skalar
<a name="graph-ql-aws-appsync-scalars-list"></a>

`AWSDate`  
String [tanggal ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Calendar_dates) yang diperpanjang dalam format. `YYYY-MM-DD`

`AWSTime`  
String [waktu ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Times) yang diperpanjang dalam format. `hh:mm:ss.sss`

`AWSDateTime`  
String [tanggal dan waktu ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Combined_date_and_time_representations) yang diperpanjang dalam format. `YYYY-MM-DDThh:mm:ss.sssZ`

**catatan**  
The`AWSDate`,`AWSTime`, dan `AWSDateTime` skalar secara opsional dapat menyertakan offset [zona waktu](https://en.wikipedia.org/wiki/ISO_8601#Time_zone_designators). Misalnya, nilai`1970-01-01Z`,`1970-01-01-07:00`, dan `1970-01-01+05:30` semuanya valid untuk`AWSDate`. Offset zona waktu harus berupa `Z` (UTC) atau offset dalam jam dan menit (dan, opsional, detik). Misalnya, `±hh:mm:ss`. Bidang detik di offset zona waktu dianggap valid meskipun bukan bagian dari standar ISO 8601.

`AWSTimestamp`  
Nilai integer yang mewakili jumlah detik sebelum atau sesudah`1970-01-01-T00:00Z`.

`AWSEmail`  
Alamat email dalam format `local-part@domain-part` seperti yang didefinisikan oleh [RFC 822](https://tools.ietf.org/html/rfc822).

`AWSJSON`  
Sebuah string JSON. Setiap konstruksi JSON yang valid secara otomatis diurai dan dimuat dalam kode resolver sebagai peta, daftar, atau nilai skalar daripada sebagai string input literal. String yang tidak dikutip atau JSON yang tidak valid menghasilkan kesalahan validasi GraphQL.

`AWSPhone`  
Nomor telepon. Nilai ini disimpan sebagai string. Nomor telepon dapat berisi spasi atau tanda hubung untuk memisahkan grup digit. Nomor telepon tanpa kode negara diasumsikan sebagai nomor AS/Amerika Utara yang mengikuti [Rencana Penomoran Amerika Utara](https://en.wikipedia.org/wiki/North_American_Numbering_Plan) (NANP).

`AWSURL`  
URL seperti yang didefinisikan oleh [RFC 1738](https://tools.ietf.org/html/rfc1738). Misalnya, `https://www.amazon.com/dp/B000NZW3KC/` atau`mailto:example@example.com`. URLsharus berisi skema (`http`,`mailto`) dan tidak dapat berisi dua garis miring (`//`) di bagian jalur.

`AWSIPAddress`  
Valid IPv4 atau IPv6 alamat. IPv4 alamat diharapkan dalam notasi quad-dotted (). `123.12.34.56` IPv6 alamat diharapkan dalam format non-kurung, dipisahkan titik dua (). `1a2b:3c4b::1234:4567` Anda dapat menyertakan akhiran CIDR opsional (`123.45.67.89/16`) untuk menunjukkan subnet mask.

## Contoh penggunaan skema
<a name="example-schema-usage"></a>

Contoh berikut skema GraphQL menggunakan semua skalar kustom sebagai “objek” dan menunjukkan permintaan resolver dan template respons untuk operasi put, get, dan list dasar. Terakhir, contoh menunjukkan bagaimana Anda dapat menggunakan ini saat menjalankan kueri dan mutasi.

```
type Mutation {
    putObject(
        email: AWSEmail,
        json: AWSJSON,
        date: AWSDate,
        time: AWSTime,
        datetime: AWSDateTime,
        timestamp: AWSTimestamp,
        url: AWSURL,
        phoneno: AWSPhone,
        ip: AWSIPAddress
    ): Object
}

type Object {
    id: ID!
    email: AWSEmail
    json: AWSJSON
    date: AWSDate
    time: AWSTime
    datetime: AWSDateTime
    timestamp: AWSTimestamp
    url: AWSURL
    phoneno: AWSPhone
    ip: AWSIPAddress
}

type Query {
    getObject(id: ID!): Object
    listObjects: [Object]
}

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

Inilah yang `putObject` mungkin terlihat seperti template permintaan. A `putObject` menggunakan `PutItem` operasi untuk membuat atau memperbarui item di tabel Amazon DynamoDB Anda. Perhatikan bahwa cuplikan kode ini tidak memiliki tabel Amazon DynamoDB yang dikonfigurasi sebagai sumber data. Ini hanya digunakan sebagai contoh:

```
{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key" : {
        "id": $util.dynamodb.toDynamoDBJson($util.autoId()),
    },
    "attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```

Template respon untuk `putObject` mengembalikan hasil:

```
$util.toJson($ctx.result)
```

Inilah yang `getObject` mungkin terlihat seperti template permintaan. A `getObject` menggunakan `GetItem` operasi untuk mengembalikan satu set atribut untuk item yang diberikan kunci utama. Perhatikan bahwa cuplikan kode ini tidak memiliki tabel Amazon DynamoDB yang dikonfigurasi sebagai sumber data. Ini hanya digunakan sebagai contoh:

```
{
    "version": "2017-02-28",
    "operation": "GetItem",
    "key": {
        "id": $util.dynamodb.toDynamoDBJson($ctx.args.id),
    }
}
```

Template respon untuk `getObject` mengembalikan hasil:

```
$util.toJson($ctx.result)
```

Inilah yang `listObjects` mungkin terlihat seperti template permintaan. A `listObjects` menggunakan `Scan` operasi untuk mengembalikan satu atau lebih item dan atribut. Perhatikan bahwa cuplikan kode ini tidak memiliki tabel Amazon DynamoDB yang dikonfigurasi sebagai sumber data. Ini hanya digunakan sebagai contoh:

```
{
    "version" : "2017-02-28",
    "operation" : "Scan",
}
```

Template respon untuk `listObjects` mengembalikan hasil:

```
$util.toJson($ctx.result.items)
```

Berikut ini adalah beberapa contoh penggunaan skema ini dengan kueri GraphQL:

```
mutation CreateObject {
    putObject(email: "example@example.com"
        json: "{\"a\":1, \"b\":3, \"string\": 234}"
        date: "1970-01-01Z"
        time: "12:00:34."
        datetime: "1930-01-01T16:00:00-07:00"
        timestamp: -123123
        url:"https://amazon.com"
        phoneno: "+1 555 764 4377"
        ip: "127.0.0.1/8"
    ) {
        id
        email
        json
        date
        time
        datetime
        url
        timestamp
        phoneno
        ip
    }
}

query getObject {
    getObject(id:"0d97daf0-48e6-4ffc-8d48-0537e8a843d2"){
        email
        url
        timestamp
        phoneno
        ip
    }
}

query listObjects {
    listObjects {
        json
        date
        time
        datetime
    }
}
```

# Antarmuka dan serikat pekerja di GraphQL
<a name="interfaces-and-unions"></a>

[Sistem tipe GraphQL mendukung Antarmuka.](https://graphql.org/learn/schema/#interfaces) Antarmuka memperlihatkan sekumpulan bidang tertentu yang harus disertakan tipe untuk mengimplementasikan antarmuka. 

[Sistem tipe GraphQL juga mendukung Unions.](https://graphql.org/learn/schema/#union-types) Serikat pekerja identik dengan antarmuka, kecuali bahwa mereka tidak mendefinisikan sekumpulan bidang yang umum. Serikat pekerja umumnya lebih disukai daripada antarmuka ketika tipe yang mungkin tidak berbagi hierarki logis.

Bagian berikut adalah referensi untuk pengetikan skema.

## Contoh antarmuka
<a name="interfaces"></a>

Kami dapat mewakili `Event` antarmuka yang mewakili segala jenis aktivitas atau pengumpulan orang. Beberapa jenis acara yang mungkin adalah`Concert`,`Conference`, dan`Festival`. Semua jenis ini memiliki karakteristik umum, termasuk nama, tempat di mana acara berlangsung, dan tanggal mulai dan berakhir. Jenis ini juga memiliki perbedaan; a `Conference` menawarkan daftar pembicara dan lokakarya, sementara `Concert` fitur band pertunjukan.

Dalam Schema Definition Language (SDL), `Event` antarmuka didefinisikan sebagai berikut:

```
interface Event {
        id: ID!
        name : String!
        startsAt: String
        endsAt: String
        venue: Venue
        minAgeRestriction: Int
}
```

Dan masing-masing jenis mengimplementasikan `Event` antarmuka sebagai berikut:

```
type Concert implements Event {
    id: ID!
    name: String!
    startsAt: String
    endsAt: String
    venue: Venue
    minAgeRestriction: Int
    performingBand: String
}

type Festival implements Event {
    id: ID!
    name: String!
    startsAt: String
    endsAt: String
    venue: Venue
    minAgeRestriction: Int
    performers: [String]
}

type Conference implements Event {
    id: ID!
    name: String!
    startsAt: String
    endsAt: String
    venue: Venue
    minAgeRestriction: Int
    speakers: [String]
    workshops: [String]
}
```

Antarmuka berguna untuk mewakili elemen yang mungkin dari beberapa jenis. Misalnya, kami dapat mencari semua acara yang terjadi di tempat tertentu. Mari tambahkan `findEventsByVenue` bidang ke skema sebagai berikut:

```
schema {
    query: Query
}

type Query {
    # Retrieve Events at a specific Venue
    findEventsAtVenue(venueId: ID!): [Event]
}

type Venue {
    id: ID!
    name: String
    address: String
    maxOccupancy: Int
}

type Concert implements Event {
    id: ID!
    name: String!
    startsAt: String
    endsAt: String
    venue: Venue
    minAgeRestriction: Int
    performingBand: String
}

interface Event {
    id: ID!
    name: String!
    startsAt: String
    endsAt: String
    venue: Venue
    minAgeRestriction: Int
}

type Festival implements Event {
    id: ID!
    name: String!
    startsAt: String
    endsAt: String
    venue: Venue
    minAgeRestriction: Int
    performers: [String]
}

type Conference implements Event {
    id: ID!
    name: String!
    startsAt: String
    endsAt: String
    venue: Venue
    minAgeRestriction: Int
    speakers: [String]
    workshops: [String]
}
```

`findEventsByVenue`Mengembalikan daftar`Event`. Karena bidang antarmuka GraphQL umum untuk semua jenis implementasi, dimungkinkan untuk memilih bidang apa pun pada `Event` antarmuka `id` (`name`,,,, `startsAt` `endsAt``venue`, dan). `minAgeRestriction` Selain itu, Anda dapat mengakses bidang pada jenis implementasi apa pun menggunakan fragmen [GraphQL](https://graphql.org/learn/queries/#fragments), selama Anda menentukan jenisnya.

Mari kita periksa contoh query GraphQL yang menggunakan antarmuka.

```
query {
  findEventsAtVenue(venueId: "Madison Square Garden") {
    id
    name
    minAgeRestriction
    startsAt

    ... on Festival {
      performers
    }

    ... on Concert {
      performingBand
    }

    ... on Conference {
      speakers
      workshops
    }
  }
}
```

Kueri sebelumnya menghasilkan satu daftar hasil, dan server dapat mengurutkan peristiwa berdasarkan tanggal mulai secara default.

```
{
  "data": {
    "findEventsAtVenue": [
      {
        "id": "Festival-2",
        "name": "Festival 2",
        "minAgeRestriction": 21,
        "startsAt": "2018-10-05T14:48:00.000Z",
        "performers": [
          "The Singers",
          "The Screamers"
        ]
      },
      {
        "id": "Concert-3",
        "name": "Concert 3",
        "minAgeRestriction": 18,
        "startsAt": "2018-10-07T14:48:00.000Z",
        "performingBand": "The Jumpers"
      },
      {
        "id": "Conference-4",
        "name": "Conference 4",
        "minAgeRestriction": null,
        "startsAt": "2018-10-09T14:48:00.000Z",
        "speakers": [
          "The Storytellers"
        ],
        "workshops": [
          "Writing",
          "Reading"
        ]
      }
    ]
  }
}
```

Karena hasil dikembalikan sebagai kumpulan peristiwa tunggal, menggunakan antarmuka untuk mewakili karakteristik umum sangat membantu untuk menyortir hasil.

## Contoh serikat
<a name="unions"></a>

Seperti yang dinyatakan sebelumnya, serikat pekerja tidak mendefinisikan kumpulan bidang umum. Hasil pencarian mungkin mewakili berbagai jenis. Dengan menggunakan `Event` skema, Anda dapat mendefinisikan `SearchResult` serikat sebagai berikut:

```
type Query {
    # Retrieve Events at a specific Venue
    findEventsAtVenue(venueId: ID!): [Event]
    # Search across all content
    search(query: String!): [SearchResult]
}

union SearchResult = Conference | Festival | Concert | Venue
```

Dalam hal ini, untuk menanyakan bidang apa pun di `SearchResult` serikat kami, Anda harus menggunakan fragmen:

```
query {
  search(query: "Madison") {
    ... on Venue {
      id
      name
      address
    }

    ... on Festival {
      id
      name
      performers
    }

    ... on Concert {
      id
      name
      performingBand
    }

    ... on Conference {
      speakers
      workshops
    }
  }
}
```

## Ketik resolusi di AWS AppSync
<a name="type-resolution-in-appsynclong"></a>

Resolusi tipe adalah mekanisme dimana mesin GraphQL mengidentifikasi nilai yang diselesaikan sebagai jenis objek tertentu.

Kembali ke contoh pencarian serikat pekerja, asalkan kueri kami menghasilkan hasil, setiap item dalam daftar hasil harus menampilkan dirinya sebagai salah satu jenis yang mungkin yang didefinisikan oleh `SearchResult` serikat pekerja (yaitu,,, `Conference` `Festival``Concert`, atau`Venue`).

Karena logika untuk mengidentifikasi `Festival` dari a `Venue` atau a `Conference` tergantung pada persyaratan aplikasi, mesin GraphQL harus diberi petunjuk untuk mengidentifikasi kemungkinan jenis kami dari hasil mentah.

Dengan AWS AppSync, petunjuk ini diwakili oleh bidang meta bernama`__typename`, yang nilainya sesuai dengan nama jenis objek yang diidentifikasi. `__typename`diperlukan untuk tipe pengembalian yang merupakan antarmuka atau serikat pekerja.

## Contoh resolusi tipe
<a name="type-resolution-example"></a>

Mari kita gunakan kembali skema sebelumnya. Anda dapat mengikuti dengan menavigasi ke konsol dan menambahkan yang berikut di bawah halaman **Skema**:

```
schema {
    query: Query
}

type Query {
    # Retrieve Events at a specific Venue
    findEventsAtVenue(venueId: ID!): [Event]
    # Search across all content
    search(query: String!): [SearchResult]
}

union SearchResult = Conference | Festival | Concert | Venue

type Venue {
    id: ID!
    name: String!
    address: String
    maxOccupancy: Int
}

interface Event {
    id: ID!
    name: String!
    startsAt: String
    endsAt: String
    venue: Venue
    minAgeRestriction: Int
}

type Festival implements Event {
    id: ID!
    name: String!
    startsAt: String
    endsAt: String
    venue: Venue
    minAgeRestriction: Int
    performers: [String]
}

type Conference implements Event {
    id: ID!
    name: String!
    startsAt: String
    endsAt: String
    venue: Venue
    minAgeRestriction: Int
    speakers: [String]
    workshops: [String]
}

type Concert implements Event {
    id: ID!
    name: String!
    startsAt: String
    endsAt: String
    venue: Venue
    minAgeRestriction: Int
    performingBand: String
}
```

Mari kita lampirkan resolver ke lapangan. `Query.search` Di `Resolvers` bagian ini, pilih **Lampirkan**, buat **Sumber Data** baru tipe *NONE*, lalu beri nama *StubDataSource*. Demi contoh ini, kita akan berpura-pura kita mengambil hasil dari sumber eksternal, dan kode keras hasil yang diambil dalam template pemetaan permintaan.

Di panel templat pemetaan permintaan, masukkan yang berikut ini:

```
{
    "version" : "2018-05-29",
    "payload":
    ## We are effectively mocking our search results for this example
    [
        {
            "id": "Venue-1",
            "name": "Venue 1",
            "address": "2121 7th Ave, Seattle, WA 98121",
            "maxOccupancy": 1000
        },
        {
            "id": "Festival-2",
            "name": "Festival 2",
            "performers": ["The Singers", "The Screamers"]
        },
        {
            "id": "Concert-3",
            "name": "Concert 3",
            "performingBand": "The Jumpers"
        },
        {
            "id": "Conference-4",
            "name": "Conference 4",
            "speakers": ["The Storytellers"],
            "workshops": ["Writing", "Reading"]
        }
    ]
}
```

Jika aplikasi mengembalikan nama tipe sebagai bagian dari `id` bidang, logika resolusi tipe harus mengurai `id` bidang untuk mengekstrak nama tipe dan kemudian menambahkan `__typename` bidang ke masing-masing hasil. Anda dapat melakukan logika itu di template pemetaan respons sebagai berikut:

**catatan**  
Anda juga dapat melakukan tugas ini sebagai bagian dari fungsi Lambda Anda, jika Anda menggunakan sumber data Lambda.

```
#foreach ($result in $context.result)
    ## Extract type name from the id field.
    #set( $typeName = $result.id.split("-")[0] )
    #set( $ignore = $result.put("__typename", $typeName))
#end
$util.toJson($context.result)
```

Jalankan kueri berikut:

```
query {
  search(query: "Madison") {
    ... on Venue {
      id
      name
      address
    }

    ... on Festival {
        id
      name
      performers
    }

    ... on Concert {
      id
      name
      performingBand
    }

    ... on Conference {
      speakers
      workshops
    }
  }
}
```

Kueri menghasilkan hasil sebagai berikut:

```
{
  "data": {
    "search": [
      {
        "id": "Venue-1",
        "name": "Venue 1",
        "address": "2121 7th Ave, Seattle, WA 98121"
      },
      {
        "id": "Festival-2",
        "name": "Festival 2",
        "performers": [
          "The Singers",
          "The Screamers"
        ]
      },
      {
        "id": "Concert-3",
        "name": "Concert 3",
        "performingBand": "The Jumpers"
      },
      {
        "speakers": [
          "The Storytellers"
        ],
        "workshops": [
          "Writing",
          "Reading"
        ]
      }
    ]
  }
}
```

Logika resolusi tipe bervariasi tergantung pada aplikasi. Misalnya, Anda dapat memiliki logika pengenal yang berbeda yang memeriksa keberadaan bidang tertentu atau bahkan kombinasi bidang. Artinya, Anda dapat mendeteksi keberadaan `performers` bidang untuk mengidentifikasi `Festival` atau kombinasi dari `speakers` dan `workshops` bidang untuk mengidentifikasi a`Conference`. Pada akhirnya, terserah Anda untuk menentukan logika yang ingin Anda gunakan.