Amplify ライブラリを使って既存の AWS バックエンドと簡単に統合してみる

buildscript {
   repositories {
       google()
       jcenter()
   }

   dependencies {
       classpath 'com.android.tools.build:gradle:4.1.2'

       // Add this line into `dependencies` in `buildscript`
       classpath 'com.amplifyframework:amplify-tools-gradle-plugin:1.0.2'
   }
}

allprojects {
   repositories {
       google()
       jcenter()
   }
}

// Add this line at the end of the file
apply plugin: 'com.amplifyframework.amplifytools'

dependencies {
    implementation 'com.amplifyframework:aws-api:1.17.1'
}

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

type Comment {
  #  A unique identifier for the comment.
  commentId: String!
  #  The comment's content.
  content: String!
  #  The comment timestamp. This field is indexed to enable sorted pagination.
  createdAt: String!
  #  The id of the comment's parent event.
  eventId: ID!
}

type CommentConnection {
  items: [Comment]
  nextToken: String
}

type Event {
  #  Paginate through all comments belonging to an individual post.
  comments(limit: Int, nextToken: String): CommentConnection
  description: String
  id: ID!
  name: String
  when: String
  where: String
}

type EventConnection {
  items: [Event]
  nextToken: String
}

type Mutation {
  #  Comment on an event.
  commentOnEvent(content: String!, createdAt: String!, eventId: ID!): Comment
  #  Create a single event.
  createEvent(description: String!, name: String!, when: String!, where: String!): Event
  #  Delete a single event by id.
  deleteEvent(id: ID!): Event
}

type Query {
  #  Get a single event by id.
  getEvent(id: ID!): Event
  #  Paginate through events.
  listEvents(filter: TableEventFilterInput, limit: Int, nextToken: String): EventConnection
}

type Subscription {
  subscribeToEventComments(eventId: String!): Comment @aws_subscribe(mutations : ["commentOnEvent"])
}

input TableBooleanFilterInput {
  eq: Boolean
  ne: Boolean
}

...

type Comment 
# @modelを追加
@model(queries: null, mutations: null, subscriptions: null) {
    commentId: String!
    content: String!
    createdAt: String!
    eventId: ID!
}

type CommentConnection 
# @modelを追加
@model {
    items: [Comment] @connection # @connectionを追加
    nextToken: String
}

type Event 
# @modelを追加
@model(queries: null, mutations: null, subscriptions: null) {
    comments(limit: Int, nextToken: String): CommentConnection @connection # @connectionを追加
    description: String
    id: ID!
    name: String
    when: String
    where: String
}

type EventConnection 
# @modelを追加
@model {
    items: [Event] @connection # @connectionを追加
    nextToken: String
}

type Mutation {
    commentOnEvent(content: String!, createdAt: String!, eventId: ID!): Comment
    createEvent(description: String!, name: String!, when: String!, where: String!): Event
    deleteEvent(id: ID!): Event
}

type Query {
    getEvent(id: ID!): Event
    listEvents(filter: TableEventFilterInput, limit: Int, nextToken: String): EventConnection
}

type Subscription {
    subscribeToEventComments(eventId: String!): Comment @aws_subscribe(mutations : ["commentOnEvent"])
}

input TableBooleanFilterInput {
    eq: Boolean
    ne: Boolean
}

input TableEventFilterInput {
    description: TableStringFilterInput
    id: TableIDFilterInput
    name: TableStringFilterInput
    when: TableStringFilterInput
    where: TableStringFilterInput
}

input TableFloatFilterInput {
    between: [Float]
    contains: Float
    eq: Float
    ge: Float
    gt: Float
    le: Float
    lt: Float
    ne: Float
    notContains: Float
}

input TableIDFilterInput {
    beginsWith: ID
    between: [ID]
    contains: ID
    eq: ID
    ge: ID
    gt: ID
    le: ID
    lt: ID
    ne: ID
    notContains: ID
}

input TableIntFilterInput {
    between: [Int]
    contains: Int
    eq: Int
    ge: Int
    gt: Int
    le: Int
    lt: Int
    ne: Int
    notContains: Int
}

input TableStringFilterInput {
    beginsWith: String
    between: [String]
    contains: String
    eq: String
    ge: String
    gt: String
    le: String
    lt: String
    ne: String
    notContains: String
}

app/src/main/java/com/amplifyframework/
└── datastore
    └── generated
        └── model
            ├── AmplifyModelProvider.java
            ├── Comment.java
            ├── CommentConnection.java
            ├── Event.java
            ├── EventConnection.java
            ├── Mutation.java
            ├── Query.java
            ├── Subscription.java
            ├── TableBooleanFilterInput.java
            ├── TableEventFilterInput.java
            ├── TableFloatFilterInput.java
            ├── TableIDFilterInput.java
            ├── TableIntFilterInput.java
            └── TableStringFilterInput.java

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    try {
        Amplify.addPlugin(AWSApiPlugin())
        Amplify.configure(applicationContext)
        Log.i("MyAmplifyApp", "Initialized Amplify")
    } catch (error: AmplifyException) {
        Log.e("MyAmplifyApp", "Could not initialize Amplify", error)
    }
    setContentView(R.layout.activity_main)
}

private fun createEventRequest(name: String, description: String, `when`: String, where: String): GraphQLRequest<Event> {
    val document = ("mutation createEvent(\$name: String!, \$description: String!, \$when: String!, \$where: String!) { "
            + "createEvent(name: \$name, description: \$description, when: \$when, where: \$where) { "
            + "id "
            + "name "
            + "}"
            + "}")
    return SimpleGraphQLRequest(
            document,
            mapOf("name" to name, "description" to description, "when" to `when`, "where" to where),
            Event::class.java,
            GsonVariablesSerializer())
}

public fun createEvent(view: View){
    Amplify.API.mutate(createEventRequest("xxxxxxx", "xxxxxxx", "xxxxxxxxxx", "xxxxxxx"),
            { Log.d("MyAmplifyApp", "Query Result = ${it.data}") },
            { Log.e("MyAmplifyApp", "Create failed", it) }
    )
}

private fun getEventRequest(id: String): GraphQLRequest<Event> {
    val document = ("query getEvent(\$id: ID!) { "
                + "getEvent(id: \$id) { "
                    + "id "
                    + "name "
                    + "description "
                    + "comments {"
                        + "items {"
                            + "commentId "
                            + "content "
                        + "}"
                    + "}"
                + "}"
            + "}")

    return SimpleGraphQLRequest(
            document,
            mapOf("id" to id),
            Event::class.java,
            GsonVariablesSerializer())
}

public fun getEvent(view: View){
    Amplify.API.query(getEventRequest("xxxxxxxxxxxxxx"),
    { Log.i("MyAmplifyApp", "Query results = ${it.data}") },
    { Log.e("MyAmplifyApp", "Query failed", it) }
    )
}

private fun listEventRequest(limit: Int?, nextToken: String?): GraphQLRequest<EventConnection> {
    val document = ("query listEvents(\$limit: Int, \$nextToken: String) { "
                + "listEvents(limit: \$limit, nextToken: \$nextToken) { "
                    + "items { "
                        + "id "
                        + "name "
                        + "when "
                        + "where "
                        + "description "
                    + "} "
                    + "nextToken "
                + "} "
            + "} ")

    return SimpleGraphQLRequest(
            document,
            mapOf("limit" to limit, "nextToken" to nextToken),
            EventConnection::class.java,
            GsonVariablesSerializer())
}

public fun listEvent(view: View){
    Amplify.API.query(listEventRequest(limit = 5, nextToken = null),
            {Log.i("Amplify List Query", "Query result = ${(it.data)}")},
            { Log.e("MyAmplifyApp", "Query failed", it) }
    )
}

private fun deleteEvent(id: String): GraphQLRequest<Event> {
    val document = ("mutation DeleteEvent(\$id: ID!) { "
            + "deleteEvent(id: \$id) { "
            + "name "
            + "id "
            + "}"
            + "}")

    return SimpleGraphQLRequest(
            document,
            mapOf("id" to id),
            Event::class.java,
            GsonVariablesSerializer ())
}

public fun deleteEvent(view: View){
    val request = deleteEvent("xxxxxxxxxxxxxxx")
    Amplify.API.mutate(request,
            { Log.i("MyAmplifyApp", "Query result = ${it.data}") },
            { Log.e("MyAmplifyApp", "Query failed", it) }
    )
}

amplifylib-appsync
├── README.md
├── node_modules
├── package.json
├── public
├── schema.graphql
├── src
├── tsconfig.json
└── yarn.lock

import {API} from '@aws-amplify/api';
import gql from 'graphql-tag'

const query = gql`
    query getEvent($id: ID!) {
      getEvent(id: $id) {
        id
        name
        description
        comments {
          items {
            commentId
            content
          }
        }
      }
    }
  }
`

const getEvent = async (id: string) => {
  const result = API.graphql({
    query: query,
    variables: {
      id: id 
    }
  })
  return result;
}