モデル関係の構築

const schema = a.schema({
  Member: a.model({
    name: a.string().required(),
    // 1. Create a reference field
    teamId: a.id(),
    // 2. Create a belongsTo relationship with the reference field
    team: a.belongsTo('Team', 'teamId'),
  }),

  Team: a.model({
    mantra: a.string().required(),
    // 3. Create a hasMany relationship with the reference field
    //    from the `Member`s model.
    members: a.hasMany('Member', 'teamId'),
  }),
}).authorization((allow) => allow.publicApiKey());

do {
    let team = Team(mantra: "Go Frontend!")
    let createdTeam = try await Amplify.API.mutate(request: .create(team)).get()

    let member = Member(
        name: "Tim",
        team: createdTeam) // Directly pass in the team instance
    let createdMember = try await Amplify.API.mutate(request: .create(member))
} catch {
    print("Create team or member failed", error)
}

do {
    let newTeam = Team(mantra: "Go Fullstack!")
    let createdNewTeam = try await Amplify.API.mutate(request: .create(newTeam)).get()

    existingMember.setTeam(createdNewTeam)
    let updatedMember = try await Amplify.API.mutate(request: .update(existingMember)).get()
} catch {
    print("Create team or update member failed", error)
}

do {
    existingMember.setTeam(nil)
    let memberRemovedTeam = try await Amplify.API.mutate(request: .update(existingMember)).get()
} catch {
    print("Failed to remove team from member", error)
}

do {
    let queriedTeam = try await Amplify.API.query(
        request: .get(
            Team.self,
            byIdentifier: team.identifier)).get()

    guard let queriedTeam, let members = queriedTeam.members else {
        print("Missing team or members")
        return
    }
    try await members.fetch()
    print("Number of members: \(members.count)")
} catch {
    print("Failed to fetch team or members", error)
}

do {
    let queriedTeamWithMembers = try await Amplify.API.query(
        request: .get(
            Team.self,
            byIdentifier: team.identifier,
            includes: { team in [team.members]}))
        .get()
    guard let queriedTeamWithMembers, let members = queriedTeamWithMembers.members else {
        print("Missing team or members")
        return
    }
    print("Number of members: \(members.count)")
} catch {
    print("Failed to fetch team with members", error)
}

const schema = a.schema({
  Cart: a.model({
    items: a.string().required().array(),
    // 1. Create reference field
    customerId: a.id(),
    // 2. Create relationship field with the reference field
    customer: a.belongsTo('Customer', 'customerId'),
  }),
  Customer: a.model({
    name: a.string(),
    // 3. Create relationship field with the reference field
    //    from the Cart model
    activeCart: a.hasOne('Cart', 'customerId')
  }),
}).authorization((allow) => allow.publicApiKey());

do {
    let customer = Customer(name: "Rene")
    let createdCustomer = try await Amplify.API.mutate(request: .create(customer)).get()

    let cart = Cart(
        items: ["Tomato", "Ice", "Mint"],
        customer: createdCustomer)
    let createdCart = try await Amplify.API.mutate(request: .create(cart)).get()
} catch {
    print("Create customer or cart failed", error)
}

do {
    let newCustomer = Customer(name: "Rene")
    let newCustomerCreated = try await Amplify.API.mutate(request: .create(newCustomer)).get()
    existingCart.setCustomer(newCustomerCreated)
    let updatedCart = try await Amplify.API.mutate(request: .update(existingCart)).get()
} catch {
    print("Create customer or cart failed", error)
}

do {
    existingCart.setCustomer(nil)
    let cartWithCustomerRemoved = try await Amplify.API.mutate(request: .update(existingCart)).get()
} catch {
    print("Failed to remove customer from cart", error)
}

do {
    guard let queriedCart = try await Amplify.API.query(
        request: .get(
            Cart.self,
            byIdentifier: existingCart.identifier)).get() else {
        print("Missing cart")
        return
    }

    let customer = try await queriedCart.customer
} catch {
    print("Failed to fetch cart or customer", error)
}

const schema = a.schema({
  PostTag: a.model({
    // 1. Create reference fields to both ends of
    //    the many-to-many relationship
Copy highlighted code example
    postId: a.id().required(),
    tagId: a.id().required(),
    // 2. Create relationship fields to both ends of
    //    the many-to-many relationship using their
    //    respective reference fields
Copy highlighted code example
    post: a.belongsTo('Post', 'postId'),
    tag: a.belongsTo('Tag', 'tagId'),
  }),
  Post: a.model({
    title: a.string(),
    content: a.string(),
    // 3. Add relationship field to the join model
    //    with the reference of `postId`
Copy highlighted code example
    tags: a.hasMany('PostTag', 'postId'),
  }),
  Tag: a.model({
    name: a.string(),
    // 4. Add relationship field to the join model
    //    with the reference of `tagId`
Copy highlighted code example
    posts: a.hasMany('PostTag', 'tagId'),
  }),
}).authorization((allow) => allow.publicApiKey());

const schema = a.schema({
  Post: a.model({
    title: a.string().required(),
    content: a.string().required(),
Copy highlighted code example
    authorId: a.id(),
    author: a.belongsTo('Person', 'authorId'),
    editorId: a.id(),
    editor: a.belongsTo('Person', 'editorId'),
  }),
  Person: a.model({
    name: a.string(),
Copy highlighted code example
    editedPosts: a.hasMany('Post', 'editorId'),
    authoredPosts: a.hasMany('Post', 'authorId'),
  }),
}).authorization((allow) => allow.publicApiKey());

do {
    guard let queriedPost = try await Amplify.API.query(
        request: .get(
            Post.self,
            byIdentifier: post.identifier)).get() else {
        print("Missing post")
        return
    }

    let loadedAuthor = try await queriedPost.author
    let loadedEditor = try await queriedPost.editor
} catch {
    print("Failed to fetch post, author, or editor", error)
}

const schema = a.schema({
  Post: a.model({
    title: a.string().required(),
    content: a.string().required(),
    // Reference fields must correspond to identifier fields.
Copy highlighted code example
    authorName: a.string(),
    authorDoB: a.date(),
    // Must pass references in the same order as identifiers.
    author: a.belongsTo('Person', ['authorName', 'authorDoB']),
  }),
  Person: a.model({
    name: a.string().required(),
    dateOfBirth: a.date().required(),
    // Must reference all reference fields corresponding to the
    // identifier of this model.
    authoredPosts: a.hasMany('Post', ['authorName', 'authorDoB']),
Copy highlighted code example
  }).identifier(['name', 'dateOfBirth']),
}).authorization((allow) => allow.publicApiKey());

const schema = a.schema({
  Post: a.model({
    title: a.string().required(),
    content: a.string().required(),
    // You must supply an author when creating the post
    // Author can't be set to `null`.
Copy highlighted code example
    authorId: a.id().required(),
    author: a.belongsTo('Person', 'authorId'),
    // You can optionally supply an editor when creating the post.
    // Editor can also be set to `null`.
Copy highlighted code example
    editorId: a.id(),
    editor: a.belongsTo('Person', 'editorId'),
  }),
  Person: a.model({
    name: a.string(),
Copy highlighted code example
    editedPosts: a.hasMany('Post', 'editorId'),
    authoredPosts: a.hasMany('Post', 'authorId'),
  }),
}).authorization((allow) => allow.publicApiKey());