schema.graphql

# **Don't delete** Comments at top of schemas should work
# See: https://github.com/dgraph-io/dgraph/issues/4227

type Hotel {
    id: ID!
    name: String! @search(by: [exact])
    location: Point @search
    area: Polygon @search
    branches: MultiPolygon @search
}

type Country {
        # **Don't delete** Comments in types should work
        id: ID! # **Don't delete** Comments in lines should work
        name: String! @search(by: [trigram, hash])
        states: [State] @hasInverse(field: country) @dgraph(pred: "hasStates")
}

type State {
        id: ID!
        xcode: String! @id @search(by: [regexp])
        name: String!
        capital: String
        region: Region
	    country: Country @dgraph(pred: "inCountry")
}

# **Don't delete** Comments in the middle of schemas should work
# Comments in input schemas should _not_ make it through to the
# generated schema.

"""
GraphQL descriptions look like this.  They should work in the input
schema and should make their way into the generated schema.
"""
type Author @dgraph(type: "test.dgraph.author") {
        id: ID!

        """
        GraphQL descriptions can be on fields.  They should work in the input
        schema and should make their way into the generated schema.
        """
        name: String! @search(by: [hash, trigram])

        dob: DateTime @search
        reputation: Float @search
        qualification: String @search(by: [hash, trigram])
        country: Country
        posts: [Post!] @hasInverse(field: author)
		bio: String @lambda
		rank: Int @lambda
}

type Post @dgraph(type: "myPost") {
        postID: ID!
        title: String! @search(by: [term, fulltext])
        text: String @search(by: [fulltext]) @dgraph(pred: "text")
        tags: [String] @search(by: [exact])
        topic: String @search(by: [exact]) @dgraph(pred: "test.dgraph.topic")
        numLikes: Int @search
        numViews: Int64 @search
        isPublished: Boolean @search @dgraph(pred: "is_published")
        postType: PostType @search(by: [hash, trigram])
        author: Author! @hasInverse(field: posts) @dgraph(pred: "post.author")
        category: Category @hasInverse(field: posts)
}

type Category {
        id: ID
        name: String
        posts: [Post]
}

type User @secret(field: "password", pred:"pwd"){
	name: String! @id
}

"""
GraphQL descriptions can be on enums.  They should work in the input
schema and should make their way into the generated schema.
"""
enum PostType {
        Fact

        """
        GraphQL descriptions can be on enum values.  They should work in the input
        schema and should make their way into the generated schema.
        """
        Question
        Opinion
}

"""
GraphQL descriptions can be on interfaces.  They should work in the input
schema and should make their way into the generated schema.
"""
interface Employee @dgraph(type: "test.dgraph.employee.en") {
        ename: String!
}

interface Character @dgraph(type: "performance.character") {
        id: ID!
        name: String! @search(by: [exact])
        appearsIn: [Episode!] @search @dgraph(pred: "appears_in")
		bio: String @lambda
}

type Human implements Character & Employee {
        id: ID!
        name: String! @search(by: [exact])
        appearsIn: [Episode!] @search
        bio: String @lambda
        ename: String!
        starships: [Starship]
        totalCredits: Float @dgraph(pred: "credits")
}

type Droid implements Character @dgraph(type: "roboDroid") {
        id: ID!
        name: String! @search(by: [exact])
        appearsIn: [Episode!] @search
        bio: String @lambda
        primaryFunction: String
}

enum Episode {
        NEWHOPE
        EMPIRE
        JEDI
}

type Starship @dgraph(type: "star.ship") {
        id: ID!
        name: String! @search(by: [term]) @dgraph(pred: "star.ship.name")
        length: Float
}

type Movie {
	id: ID!
	name: String!
	director: [MovieDirector] @dgraph(pred: "~directed.movies")
}

type MovieDirector {
	id: ID!
	name: String!
	directed: [Movie] @dgraph(pred: "directed.movies")
}

interface People {
	id: ID!
	xid: String! @id
	name: String!
}

type Teacher implements People {
	subject: String
	teaches: [Student]
}

type Student implements People {
        taughtBy: [Teacher] @hasInverse(field: "teaches")
}

type Message @withSubscription {
    content: String! @dgraph(pred: "post")
    author: String @dgraph(pred: "<职业>")
}

"""
This is used for fragment related testing
"""
interface Thing {
	name: String # field to act as a common inherited field for both ThingOne and ThingTwo
}

type ThingOne implements Thing {
	id: ID! # ID field with same name as the ID field in ThingTwo
	color: String # field with same name as a field in ThingTwo
	usedBy: String # field with different name than any field in ThingTwo
}

type ThingTwo implements Thing {
	id: ID!
	color: String
	owner: String
}

type Post1 {
       id: String! @id
       comments: [Comment1]
}

type Comment1 {
      id: String! @id
      replies: [Comment1]
}
type post1{
    id: ID
    title: String! @id @search(by: [regexp])
    numLikes: Int64 @search
    commentsByMonth: [Int]
    likesByMonth: [Int64]
    author: author1 @hasInverse(field: posts)
}

type Person1 {
    id: ID!
    name: String!
    friends: [Person1] @hasInverse(field: friends)
}

# union testing - start
enum AnimalCategory {
	Fish
	Amphibian
	Reptile
	Bird
	Mammal
	InVertebrate
}

interface Animal {
	id: ID!
	category: AnimalCategory @search
}

type Dog implements Animal {
	breed: String @search
}

type Parrot implements Animal {
	repeatsWords: [String]
}

type Cheetah implements Animal {
	speed: Float
}

"""
This type specifically doesn't implement any interface.
We need this to test out all cases with union.
"""
type Plant {
	id: ID!
	breed: String # field with same name as a field in type Dog
}

union HomeMember = Dog | Parrot | Human | Plant

type Zoo {
	id: ID!
	animals: [Animal]
	city: String
}

type Home {
	id: ID!
	address: String
	members: [HomeMember]
	favouriteMember: HomeMember
}
# union testing - end

type Query {
	authorsByName(name: String!): [Author] @lambda
}

type Mutation {
	newAuthor(name: String!): ID! @lambda
}

# generate directive testing
type University @generate(
    query: {
        query: false
    },
    mutation: {
        add: true,
        update: true,
        delete: false
    }
){
    id: ID!
    name: String!
    numStudents: Int
}

# @id directive with multiple data types
type Book {
    bookId: Int64! @id
    name: String!
    desc: String
	summary: String @lambda
	chapters: [Chapter] @hasInverse(field: book)
}

type Chapter {
    chapterId: Int! @id
    name: String!
	book: Book
}

type Section {
    sectionId: Float! @id
    name: String!
    chapterId: Int! @search
}

type Mission @key(fields: "id") {
    id: String! @id
    crew: [Astronaut] @hasInverse(field: missions)
    spaceShip: [SpaceShip]
    designation: String!
    startDate: String
    endDate: String
}

type Astronaut @key(fields: "id") @extends {
    id: ID! @external
    missions: [Mission]
}

type SpaceShip @key(fields: "id") @extends {
    id: String! @id @external
    missions: [Mission]
}

type Region {
    id: String! @id
    name: String!
    district: District
}

type District {
    id: String! @id
    name: String!
}

type Owner {
    username: String! @id
    password: String!
    projects: [Project!] @hasInverse(field: owner)
}

type Project {
    id: String! @id
    owner: Owner!
    name: String! @search(by: [hash])
    datasets: [Dataset!] @hasInverse(field: project)
}

type Dataset {
    id: String! @id
    owner: Owner!
    project: Project!
    name: String! @search(by: [hash])
}

type author1{
    name:String! @id @search(by: [regexp])
    posts:[post1] @hasInverse(field: author)
}
# multiple fields with @id directive
type Worker {
    name: String!
    reg_No: Int! @id
    emp_Id: String! @id
}

type Employer {
    company: String! @id
    worker: [Worker]
}