Set up Amplify Data

import { a, defineData, type ClientSchema } from '@aws-amplify/backend';

const schema = a.schema({
  Todo: a.model({
      content: a.string(),
      isDone: a.boolean()
    })
    .authorization(allow => [allow.publicApiKey()])
});

// Used for code completion / highlighting when making requests from frontend
export type Schema = ClientSchema<typeof schema>;

// defines the data resource to be deployed
export const data = defineData({
  schema,
  authorizationModes: {
    defaultAuthorizationMode: 'apiKey',
    apiKeyAuthorizationMode: { expiresInDays: 30 }
  }
});

npx ampx sandbox --outputs-out-dir <path_to_swift_project>

import SwiftUI
Copy highlighted code example
import Amplify
import AWSAPIPlugin

@main
struct MyAmplifyApp: App {

Copy highlighted code example
    init() {
        let awsApiPlugin = AWSAPIPlugin(modelRegistration: AmplifyModels())
        do {
            try Amplify.add(plugin: awsApiPlugin)
            try Amplify.configure(with: .amplifyOutputs)
            print("Initialized Amplify");
        } catch {
            // simplified error handling for the tutorial
            print("Could not initialize Amplify: \(error)")
        }
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

npx ampx generate graphql-client-code --format modelgen --model-target swift --out <path_to_swift_project>/AmplifyModels

import Foundation
import Amplify

@MainActor
class TodoViewModel: ObservableObject {
    func createTodo() {
        let todo = Todo(
            content: "Build iOS Application",
            isDone: false
        )
        Task {
            do {
                let result = try await Amplify.API.mutate(request: .create(todo))
                switch result {
                case .success(let todo):
                    print("Successfully created todo: \(todo)")
                case .failure(let error):
                    print("Got failed result with \(error.errorDescription)")
                }
            } catch let error as APIError {
                print("Failed to create todo: ", error)
            } catch {
                print("Unexpected error: \(error)")
            }
        }
    }
}

struct ContentView: View {

Copy highlighted code example
    // Create an observable object instance.
    @StateObject var vm = TodoViewModel()

    var body: some View {
Copy highlighted code example
        VStack {
            Button(action: {
                vm.createTodo()
            }) {
                HStack {
                    Text("Add a New Todo")
                    Image(systemName: "plus")
                }
            }
            .accessibilityLabel("New Todo")
        }
    }
}

Successfully created todo: Todo(id: XYZ ...)

@MainActor
class TodoViewModel: ObservableObject {

Copy highlighted code example
    @Published var todos: [Todo] = []

    func createTodo() {
        /// ...
    }

Copy highlighted code example
    func listTodos() {
        Task {
            do {
                let result = try await Amplify.API.query(request: .list(Todo.self))
                switch result {
                case .success(let todos):
                    print("Successfully retrieved list of todos: \(todos)")
                    self.todos = todos.elements
                case .failure(let error):
                    print("Got failed result with \(error.errorDescription)")
                }
            } catch let error as APIError {
                print("Failed to query list of todos: ", error)
            } catch {
                print("Unexpected error: \(error)")
            }
        }
    }
}

import SwiftUI
import Amplify

struct ContentView: View {
    @StateObject var vm = TodoViewModel()

    var body: some View {
        VStack {
Copy highlighted code example
            List(vm.todos, id: \.id) { todo in
                Text(todo.content ?? "")
            }
            // .. Add a new Todo button
        }
Copy highlighted code example
        .task {
            await vm.listTodos()
        }
    }
}

@MainActor
class TodoViewModel: ObservableObject {
    @Published var todos: [Todo] = []

Copy highlighted code example
    private var subscription: AmplifyAsyncThrowingSequence<GraphQLSubscriptionEvent<Todo>>

    init() {
       self.subscription = Amplify.API.subscribe(request: .subscription(of: Todo.self, type: .onCreate))
    }

    func subscribe() {
        Task {
            do {
                for try await subscriptionEvent in subscription {
                    handleSubscriptionEvent(subscriptionEvent)
                }
            } catch {
                print("Subscription has terminated with \(error)")
            }
        }
    }

    private func handleSubscriptionEvent(_ subscriptionEvent: GraphQLSubscriptionEvent<Todo>) {
        switch subscriptionEvent {
        case .connection(let subscriptionConnectionState):
            print("Subscription connect state is \(subscriptionConnectionState)")
        case .data(let result):
            switch result {
            case .success(let createdTodo):
                print("Successfully got todo from subscription: \(createdTodo)")
                todos.append(createdTodo)
            case .failure(let error):
                print("Got failed result with \(error.errorDescription)")
            }
        }
    }

    func cancel() {
        self.subscription.cancel()
    }

    func createTodo() {
        /// ...
    }

    func listTodos() {
        /// ...
    }
}

struct ContentView: View {
    @StateObject var vm = TodoViewModel()

    var body: some View {
        VStack {
            // ...
        }
Copy highlighted code example
        .onDisappear {
            vm.cancel()
        }
        .task {
            vm.listTodos()
            vm.subscribe()
        }
    }
}