データモデルをカスタマイズする

type Todo @model {
  content: String
}

query QueryAllTodos {
  listTodos() {
    todos {
      items {
        id
        content
        createdAt
        updatedAt
      }
    }
  }
}

import { Amplify } from 'aws-amplify';
import { generateClient } from 'aws-amplify/api';
import config from './amplifyconfiguration.json';
import { listTodos } from './graphql/queries';

const client = generateClient();

Amplify.configure(config);

try {
  const result = await client.graphql({ query: listTodos });
  const todos = result.data.listTodos;
} catch (res) {
  const { errors } = res;
  console.error(errors);
}

type Todo @model {
  todoId: ID! @primaryKey
  content: String
}

type Inventory @model {
  productID: ID! @primaryKey(sortKeyFields: ["warehouseID"])
  warehouseID: ID!
  InventoryAmount: Int!
}

query QueryInventoryByProductAndWarehouse($productID: ID!, $warehouseID: ID!) {
  getInventory(productID: $productID, warehouseID: $warehouseID) {
    productID
    warehouseID
    inventoryAmount
  }
}

import { getInventory } from './graphql/queries';

const result = await client.graphql({
  query: getInventory,
  variables: {
    productID: 'product-id',
    warehouseID: 'warehouse-id'
  }
});
const inventory = result.data.getInventory;

type Customer @model {
  id: ID!
  name: String!
  phoneNumber: String
  accountRepresentativeID: ID! @index
}

query QueryCustomersForAccountRepresentative($accountRepresentativeID: ID!) {
  customersByAccountRepresentativeID(
    accountRepresentativeID: $accountRepresentativeID
  ) {
    customers {
      items {
        id
        name
        phoneNumber
      }
    }
  }
}

import { customersByAccountRepresentativeID } from './graphql/queries';

const result = await client.graphql({
  query: customersByAccountRepresentativeID,
  variables: {
    accountRepresentativeID: 'account-rep-id'
  }
});
const customers = result.data.customersByAccountRepresentativeID;

type Customer @model {
  id: ID!
  name: String!
  phoneNumber: String
  accountRepresentativeID: ID!
    @index(name: "byRepresentative", queryField: "customerByRepresentative")
}

query QueryCustomersForAccountRepresentative($representativeId: ID!) {
  customerByRepresentative(accountRepresentativeID: $representativeId) {
    customers {
      items {
        id
        name
        phoneNumber
      }
    }
  }
}

import { customerByRepresentative } from './graphql/queries';

const result = await client.graphql({
  query: customerByRepresentative,
  variables: {
    accountRepresentativeID: 'account-rep-id'
  }
});
const customer = result.data.customerByRepresentative;

type Customer @model @auth(rules: [{ allow: public }]) {
  id: ID!
  name: String! @index(name: "byNameAndPhoneNumber", sortKeyFields: ["phoneNumber"], queryField: "customerByNameAndPhone")
  phoneNumber: String
  accountRepresentativeID: ID! @index

query MyQuery {
  customerByNameAndPhone(phoneNumber: { beginsWith: "+1" }, name: "Rene") {
    items {
      id
      name
      phoneNumber
    }
  }
}

import { customerByNameAndPhone } from './graphql/queries';

const result = await client.graphql({
  query: customerByNameAndPhone,
  variables: {
    phoneNumber: { beginsWith: '+1' },
    name: 'Rene'
  }
});

const customer = result.data.customerByNameAndPhone;

type Project @model {
  id: ID!
  name: String
  team: Team @hasOne
}

type Team @model {
  id: ID!
  name: String!
}

mutation CreateProject {
  createProject(input: { projectTeamId: "team-id", name: "Some Name" }) {
    team {
      name
      id
    }
    name
    id
  }
}

import { createProject } from './graphql/mutations';

const result = await client.graphql({
  query: createProject,
  variables: {
    input: { projectTeamId: 'team-id', name: 'Some Name' }
  }
});

const project = result.data.createProject;

type Project @model {
  id: ID!
  name: String
  teamID: ID
  team: Team @hasOne(fields: ["teamID"])
}

type Team @model {
  id: ID!
  name: String!
}

mutation CreateProject {
  createProject(input: { name: "New Project", teamID: "a-team-id" }) {
    id
    name
    team {
      id
      name
    }
  }
}

import { createProject } from './graphql/mutations';

const result = await client.graphql({
  query: createProject,
  variables: {
    input: {
      teamID: 'team-id',
      name: 'New Project'
    }
  }
});
const project = result.data.createProject;

type Post @model {
  id: ID!
  title: String!
  comments: [Comment] @hasMany
}

type Comment @model {
  id: ID!
  content: String!
}

mutation CreatePost {
  createPost(input: { title: "Hello World!!" }) {
    title
    id
    comments {
      items {
        id
        content
      }
    }
  }
}

import { createPost } from './graphql/mutations';

const result = await client.graphql({
  query: createPost,
  variables {
    input: { title: 'Hello World!!' },
  }
});
const post = result.data.createPost;
const comments = post.comments.items;

type Post @model {
  id: ID!
  title: String!
  comments: [Comment] @hasMany(indexName: "byPost", fields: ["id"])
}

type Comment @model {
  id: ID!
  postID: ID! @index(name: "byPost", sortKeyFields: ["content"])
  content: String!
}

mutation CreatePost {
  createPost(input: { title: "Hello world!" }) {
    comments {
      items {
        postID
        content
        id
      }
    }
    title
    id
  }
}

import { createPost, createComment } from './graphql/mutations';
import { getPost } from './graphql/mutations';

// create post
const result = await client.graphql({
  query: createPost,
  variables: {
    input: { title: 'Hello World!!' }
  }
});
const post = result.data.createPost;

// create comment
await client.graphql({
  query: createComment,
  variables: {
    input: { content: 'Hi!', postID: post.id }
  }
});

// get post
const result = await client.graphql({
  query: getPost,
  variables: { id: post.id }
});

const postWithComments = result.data.createPost;
const postComments = postWithComments.comments.items; // access comments from post

type Post @model {
  id: ID!
  title: String!
  comments: [Comment] @hasMany(indexName: "byPost", fields: ["id"])
}

type Comment @model {
  id: ID!
  postID: ID! @index(name: "byPost", sortKeyFields: ["content"])
  content: String!
  post: Post @belongsTo(fields: ["postID"])
}

type Post @model {
  id: ID!
  title: String!
  content: String
  tags: [Tag] @manyToMany(relationName: "PostTags")
}

type Tag @model {
  id: ID!
  label: String!
  posts: [Post] @manyToMany(relationName: "PostTags")
}

mutation CreatePost {
  createPost(input: { title: "Hello World!!" }) {
    id
    title
    content
    tags {
      # queries the "join table" PostTags
      items {
        tag {
          # related Tag records from Post
          id
          label
          posts {
            # queries the "join table" PostTags
            items {
              post {
                # related Post records from Tag
                id
                title
                content
              }
            }
          }
        }
      }
    }
  }
}

import { createPost, createTag, createPostTags } from './graphql/mutations';
import { listPosts } from './graphql/queries';

// create post
const result = await client.graphql({
  query: createPost,
  variables: {
    input: { title: 'Hello World' }
  }
});
const post = result.data.createPost;

// create tag
const tagResult = await client.graphql({
  query: createTag,
  variables: {
    input: {
      label: 'My Tag'
    }
  }
});
const tag = tagResult.data.createTag;

// connect post and tag
await client.graphql({
  query: createPostTags,
  variables: {
    input: {
      postId: post.id,
      tagId: tag.id
    }
  }
});

// get posts
const listPostsResult = await client.graphql({ query: listPosts });
const posts = listPostsResult.data.listPosts;

const postTags = posts[0].tags; // access tags from post

type Todo @model {
  content: String @default(value: "My new Todo")
  # Note: all "value" parameters must be passed as a string value.
  # Under the hood, Amplify will parse the string values into respective types.
  # For example, to set a default value for an integer field,
  # you must pass in `"0"` instead of `0` without the double-quotes.
  likes: Int @default(value: "0") #
}

type Task @model {
  title: String!
  description: String
  type: String
  priority: Int
}

subscription OnCreateTask {
  onCreateTask(
    filter: { and: [{ type: { eq: "Security" } }, { priority: { gt: 5 } }] }
  ) {
    title
    description
    type
    priority
  }
}

import { onCreateTask } from './graphql/subscriptions';

const subscription = client.graphql({
  query: onCreateTask,
  variables: {
    filter: {
      and: [
        { type: { eq: "Security" } }
        { priority: { gt: 5 } }
      ]
    }
  }
}).subscribe({
	next: ({ data }) => console.log(data),
	error: (error) => console.warn(error)
});

type Todo @model(queries: { get: "queryFor" }) {
  name: String!
  description: String
}

type Todo @model(queries: { get: null }, mutations: null, subscriptions: null) {
  name: String!
  description: String
}

type Query {
  getMyTodo(id: ID!): Todo @function(name: "getmytodofunction-${env}")
}

type Todo
  @model(timestamps: { createdAt: "createdOn", updatedAt: "updatedOn" }) {
  name: String!
  description: String
}

type Todo {
  id: ID!
  name: String!
  description: String
  createdOn: AWSDateTime!
  updatedOn: AWSDateTime!
}

type Todo
  @model(subscriptions: { level: off }) { # or level: public
  name: String!
  description: String
}

type Individual @model {
  id: ID!
  homeAddress: Address @hasOne
  shippingAddress: Address @hasOne
}

type Address @model {
  id: ID!
  homeIndividualID: ID
  shippingIndividualID: ID
  homeIndividual: Individual @belongsTo(fields: ["homeIndividualID"])
  shipIndividual: Individual @belongsTo(fields: ["shippingIndividualID"])
}

type Customer @model {
  id: ID!
  name: String!
  phoneNumber: String
  accountRepresentativeID: ID! @index(queryField: null)
}

🛑 Schema validation failed.

There can be only one type named "Query".

type Query {
  # initial custom queries
  myQuery: String @function(name: "myQueryFunction-${env}")
}

extend type Query {
  # additional custom queries
  myQuery2: String @function(name: "myQuery2Function-${env}")
}

directive @model(
  queries: ModelQueryMap
  mutations: ModelMutationMap
  subscriptions: ModelSubscriptionMap
  timestamps: TimestampConfiguration
) on OBJECT

input ModelMutationMap {
  create: String
  update: String
  delete: String
}

input ModelQueryMap {
  get: String
  list: String
}

input ModelSubscriptionMap {
  onCreate: [String]
  onUpdate: [String]
  onDelete: [String]
  level: ModelSubscriptionLevel
}

enum ModelSubscriptionLevel {
  off
  public
  on
}

input TimestampConfiguration {
  createdAt: String
  updatedAt: String
}