dgraph_schemagen_test.yml

schemas:
  - name: "Object data type"
    input: |
      type A {
        id: ID!
        p: P
      }
      type P {
        id: ID!
        q: A
      }
    output: |
      type A {
        A.p
      }
      A.p: uid .
      type P {
        P.q
      }
      P.q: uid .

  - name: "Scalar list"
    input: |
      type X {
        id: ID!
        names: [String!]
      }
    output: |
      type X {
        X.names
      }
      X.names: [string] .

  - name: "Password type"
    input: |
      type X @secret(field: "pwd"){
        id: ID!
        names: [String!]
      }
    output: |
      type X {
        X.names
        X.pwd
      }
      X.names: [string] .
      X.pwd: password .


  - name: "Object list"
    input: |
      type X {
        p: [P!]!
      }
      type P {
        id: ID!
        name: String
      }
    output: |
      type X {
        X.p
      }
      X.p: [uid] .
      type P {
        P.name
      }
      P.name: string .

  - name: "Scalar types"
    input: |
      type X {
        p: Int
        pList: [Int]
        q: Boolean
        r: String
        rList: [String]
        s: DateTime
        sList: [DateTime]
        t: Float
        tList: [Float]
        u: ID
        v: Int64
        vList: [Int64]
      }
    output: |
      type X {
        X.p
        X.pList
        X.q
        X.r
        X.rList
        X.s
        X.sList
        X.t
        X.tList
        X.v
        X.vList
      }
      X.p: int .
      X.pList: [int] .
      X.q: bool .
      X.r: string .
      X.rList: [string] .
      X.s: dateTime .
      X.sList: [dateTime] .
      X.t: float .
      X.tList: [float] .
      X.v: int .
      X.vList: [int] .

  - name: "enum - always gets an index"
    input: |
      type X {
        e: E
        f: [E]
      }
      enum E { A }
    output: |
      type X {
        X.e
        X.f
      }
      X.e: string @index(hash) .
      X.f: [string] @index(hash) .


  - name: "Search indexes are correct"
    input: |
      type X {
        i1: Int @search
        i2: Int @search(by: [int])
        i64_1: Int64 @search
        i64_2: Int64 @search(by: [int64])
        f1: Float @search
        f2: Float @search(by: [float])
        b1: Boolean @search
        b2: Boolean @search(by: [bool])
        s1: String @search
        s2: String @search(by: [hash])
        s3: String @search(by: [exact])
        s4: String @search(by: [term])
        s5: String @search(by: [fulltext])
        s6: String @search(by: [trigram])
        s7: String @search(by: [regexp])
        s8: String @search(by: [exact, fulltext, term, trigram])
        dt1: DateTime @search
        dt2: DateTime @search(by: [year])
        dt3: DateTime @search(by: [month])
        dt4: DateTime @search(by: [day])
        dt5: DateTime @search(by: [hour])
        e: E @search
        e1: E @search(by: [hash])
        e2: E @search(by: [exact])
        e3: E @search(by: [trigram])
        e4: E @search(by: [regexp])
        e5: E @search(by: [hash, regexp])
        e6: E @search(by: [hash, trigram])
        e7: E @search(by: [exact, regexp])
      }
      enum E { A }
    output: |
      type X {
        X.i1
        X.i2
        X.i64_1
        X.i64_2
        X.f1
        X.f2
        X.b1
        X.b2
        X.s1
        X.s2
        X.s3
        X.s4
        X.s5
        X.s6
        X.s7
        X.s8
        X.dt1
        X.dt2
        X.dt3
        X.dt4
        X.dt5
        X.e
        X.e1
        X.e2
        X.e3
        X.e4
        X.e5
        X.e6
        X.e7
      }
      X.i1: int @index(int) .
      X.i2: int @index(int) .
      X.i64_1: int @index(int) .
      X.i64_2: int @index(int) .
      X.f1: float @index(float) .
      X.f2: float @index(float) .
      X.b1: bool @index(bool) .
      X.b2: bool @index(bool) .
      X.s1: string @index(term) .
      X.s2: string @index(hash) .
      X.s3: string @index(exact) .
      X.s4: string @index(term) .
      X.s5: string @index(fulltext) .
      X.s6: string @index(trigram) .
      X.s7: string @index(trigram) .
      X.s8: string @index(exact, fulltext, term, trigram) .
      X.dt1: dateTime @index(year) .
      X.dt2: dateTime @index(year) .
      X.dt3: dateTime @index(month) .
      X.dt4: dateTime @index(day) .
      X.dt5: dateTime @index(hour) .
      X.e: string @index(hash) .
      X.e1: string @index(hash) .
      X.e2: string @index(exact) .
      X.e3: string @index(trigram) .
      X.e4: string @index(trigram) .
      X.e5: string @index(hash, trigram) .
      X.e6: string @index(hash, trigram) .
      X.e7: string @index(exact, trigram) .

  - name: "interface and types interact properly"
    input: |
      interface A {
        id: ID!
        name: String! @search(by: [exact])
      }
      type B implements A {
        correct: Boolean @search
      }
      type C implements A {
        dob: DateTime!
      }
    output: |
      type A {
        A.name
      }
      A.name: string @index(exact) .
      type B {
        A.name
        B.correct
      }
      B.correct: bool @index(bool) .
      type C {
        A.name
        C.dob
      }
      C.dob: dateTime .

  - name: "interface using other interface generate type in dgraph"
    input: |
      interface A {
        id: ID!
        data: [D]
      }
      type C implements A {
          lname: String
      }
      interface B {
          name: String! @id
          fname: String!
      }
      type D implements B {
        link: A 
        correct: Boolean!
      }
    output: |
      type A {
        A.data
      }
      A.data: [uid] .
      type C {
        A.data
        C.lname
      }
      C.lname: string .
      type B {
        B.name
        B.fname
      }
      B.name: string @index(hash) @upsert .
      B.fname: string .
      type D {
        B.name
        B.fname
        D.link
        D.correct
      }
      D.link: uid .
      D.correct: bool .

  - name: "Schema with union"
    input: |
      interface W {
        f1: ID!
        f7: U
      }
      type X implements W {
        f2: String
      }
      type Y implements W {
        f3: Int
      }
      type Z {
        f4: Float
      }
      union P @remote = X | Y
      union U = X | Y | Z
      type V {
        id: ID!
        f5: [U!]! @dgraph(pred: "data")
        f6: U
      }
    output: |
      type W {
        W.f7
      }
      W.f7: uid .
      type X {
        W.f7
        X.f2
      }
      X.f2: string .
      type Y {
        W.f7
        Y.f3
      }
      Y.f3: int .
      type Z {
        Z.f4
      }
      Z.f4: float .
      type V {
        data
        V.f6
      }
      data: [uid] .
      V.f6: uid .

  - name: "Schema with @dgraph directive."
    input: |
      type A @dgraph(type: "dgraph.type.A") {
        id: ID!
        p: Int
        pList: [Int] @dgraph(pred: "pList")
        q: Boolean
        r: String @dgraph(pred: "dgraph.r")
        rList: [String]
        s: DateTime @dgraph(pred: "s")
        t: Float
        tList: [Float] @dgraph(pred: "dgraph.tList")
      }

      interface B @dgraph(type: "dgraph.interface.B") {
        id: ID!
        name: String! @search(by: [exact]) @dgraph(pred: "dgraph.abc.name")
        age: Int
      }

      type C implements B @dgraph(type: "type.C") {
        correct: Boolean @search @dgraph(pred: "dgraph.correct")
        incorrect: Boolean
      }

      type X @dgraph(type: "dgraph.type.X") {
        e: E @dgraph(pred: "dgraph.x.e")
        f: [E] @dgraph(pred: "dgraph.x.eList")
      }
      enum E { A }

      type Y {
        p: Int
        q: String
        pList: [Int] @dgraph(pred: "dgraph.pList")
        f: Float @dgraph(pred: "f")
      }
    output: |
      type dgraph.type.A {
        dgraph.type.A.p
        pList
        dgraph.type.A.q
        dgraph.r
        dgraph.type.A.rList
        s
        dgraph.type.A.t
        dgraph.tList
      }
      dgraph.type.A.p: int .
      pList: [int] .
      dgraph.type.A.q: bool .
      dgraph.r: string .
      dgraph.type.A.rList: [string] .
      s: dateTime .
      dgraph.type.A.t: float .
      dgraph.tList: [float] .
      type dgraph.interface.B {
        dgraph.abc.name
        dgraph.interface.B.age
      }
      dgraph.abc.name: string @index(exact) .
      dgraph.interface.B.age: int .
      type type.C {
        dgraph.abc.name
        dgraph.interface.B.age
        dgraph.correct
        type.C.incorrect
      }
      dgraph.correct: bool @index(bool) .
      type.C.incorrect: bool .
      type dgraph.type.X {
        dgraph.x.e
        dgraph.x.eList
      }
      dgraph.x.e: string @index(hash) .
      dgraph.x.eList: [string] @index(hash) .
      type Y {
        Y.p
        Y.q
        dgraph.pList
        f
      }
      Y.p: int .
      Y.q: string .
      dgraph.pList: [int] .
      f: float .

  - name: "Schema with multiple language tags, indexes on language tag fields got merged on language untagged field"
    input: |
      interface Node {
        f1: String
      }
      type Person implements Node {
        f1Hi: String @dgraph(pred: "Node.f1@hi")
        f2: String @dgraph(pred: "T.f@no")
        f3: String @dgraph(pred: "f3@en")
        name: String! @id
        nameHi: String @dgraph(pred: "Person.name@hi") @search(by: [term, exact])
        nameEn: String @dgraph(pred: "Person.name@en") @search(by: [regexp])
        nameHiEn: String @dgraph(pred: "Person.name@hi:en")
        nameHi_En_Untag: String @dgraph(pred: "Person.name@hi:en:.")
        name_Untag_AnyLang: String @dgraph(pred: "Person.name@.")
        address: String @search(by: [fulltext])
        addressHi: String @dgraph(pred: "Person.address@hi")
        professionEn: String @dgraph(pred: "Person.profession@en")
      }
    output: |
      type Node {
        Node.f1
      }
      Node.f1: string @lang .
      type Person {
        Node.f1
        Person.name
        Person.address
        Person.profession
      }
      Person.name: string @index(exact, hash, term, trigram) @lang @upsert .
      Person.address: string @index(fulltext) @lang .
      Person.profession: string @lang .

  - name: "Field with @id directive but no search directive gets hash index."
    input: |
      interface A {
        id: String! @id
      }
      type B implements A {
        correct: Boolean @search
      }
    output: |
      type A {
        A.id
      }
      A.id: string @index(hash) @upsert .
      type B {
        A.id
        B.correct
      }
      B.correct: bool @index(bool) .

  - name: "Field with @id directive gets hash index."
    input: |
      interface A {
        id: String! @id @search(by: [trigram])
      }
      type B implements A {
        correct: Boolean @search
      }
    output: |
      type A {
        A.id
      }
      A.id: string @index(hash, trigram) @upsert .
      type B {
        A.id
        B.correct
      }
      B.correct: bool @index(bool) .

  - name: "Field with @id directive and a hash arg in search directive generates correct schema."
    input: |
      interface A {
        id: String! @id @search(by: [hash, term])
      }
      type B implements A {
        correct: Boolean @search
      }
    output: |
      type A {
        A.id
      }
      A.id: string @index(hash, term) @upsert .
      type B {
        A.id
        B.correct
      }
      B.correct: bool @index(bool) .

  - name: "Field with @id directive and a exact arg in search directive generates correct schema."
    input: |
      interface A {
        id: String! @id @search(by: [exact])
      }
      type B implements A {
        correct: Boolean @search
      }
    output: |
      type A {
        A.id
      }
      A.id: string @index(exact) @upsert .
      type B {
        A.id
        B.correct
      }
      B.correct: bool @index(bool) .

  - name: "Field with reverse predicate in dgraph directive adds @reverse to predicate."
    input: |
      type Movie {
        director: [Person] @dgraph(pred: "~directed.movies")
      }
      type Person {
        directed: [Movie] @dgraph(pred: "directed.movies")
      }
    output: |
      type Movie {
      }
      type Person {
        directed.movies
      }
      directed.movies: [uid] @reverse .

  - name: "Field with reverse predicate in dgraph directive where actual predicate comes first."
    input: |
      type Person {
        directed: [Movie] @dgraph(pred: "directed.movies")
      }
      type Movie {
        director: [Person] @dgraph(pred: "~directed.movies")
      }
    output: |
      type Person {
        directed.movies
      }
      directed.movies: [uid] @reverse .
      type Movie {
      }

  - name: "deprecated fields get included in Dgraph schema"
    input: |
      type A {
        id: ID!
        p: String @deprecated
        q: String @deprecated(reason: "just because it is")
      }
    output: |
      type A {
        A.p
        A.q
      }
      A.p: string .
      A.q: string .

  - name: "remote types shouldn't be part of Dgraph schema"
    input: |
      type B {
        id: ID!
        q: String
      }

      interface C @remote{
        c: String
      }

      type A implements C @remote {
        id: ID!
        p: String
        q: String
      }
    output: |
      type B {
        B.q
      }
      B.q: string .

  - name: "fields with same @dgraph(pred: ...) occur only once in schema"
    input: |
      interface A {
        p: String @dgraph(pred: "key")
      }
      type B implements A {
        q: String @dgraph(pred: "name")
      }
      type C {
        r: String @dgraph(pred: "name")
        s: String @dgraph(pred: "key")
        name: String
      }
    output: |
      type A {
        key
      }
      key: string .
      type B {
        key
        name
      }
      name: string .
      type C {
        name
        key
        C.name
      }
      C.name: string .

  - name: "fields with same @dgraph(pred: ...) and different @search(by: [...]) have indexes
    combined"
    input: |
      type A {
        p: String @dgraph(pred: "name") @search(by: [exact, term])
      }
      type B {
        q: String @dgraph(pred: "name") @search(by: [trigram])
      }
      type C {
        q: String @dgraph(pred: "name") @search(by: [exact, term])
      }
    output: |
      type A {
        name
      }
      name: string @index(exact, term, trigram) .
      type B {
        name
      }
      type C {
        name
      }

  - name: "fields with @dgraph(pred: ...) contain different language."
    input: |
      type A {
          content: String! @dgraph(pred: "post") @search(by: [exact, term])
          author: String @dgraph(pred: "<公司>") @search(by: [exact, term])
      }
    output: |
      type A {
        post
        <公司>
      }
      post: string @index(exact, term) .
      <公司>: string @index(exact, term) .

  - name: "custom query and mutation shouldn't be part of Dgraph schema"
    input: |
      type User @remote {
        id: ID!
        name: String!
      }

      type Query {
        favUsers(id: ID!, name: String!): [User] @custom(http: {
          url: "http://mock:8888/users",
          method: "GET"
        })
      }

      type Mutation {
        setFavUsers(id: ID!, name: String!): [User] @custom(http: {
          url: "http://mock:8888/users",
          method: "POST"
        })
      }

  - name: "custom field shouldn't be part of dgraph schema"
    input: |
      type User {
        id: ID!
        name: String!
        bio: String! @lambda
        friends: [User] @custom(http: {
          url: "http://mock:8888/users",
          method: "GET"
        })
      }
    output: |
      type User {
        User.name
      }
      User.name: string .

  - name: "Geo field in schema."
    input: |
      type Hotel {
        id: ID!
        name: String!
        location: Point @search
        landmark: Point
        office: Point  @search(by: [point])
        area1: Polygon @search
        area2: Polygon
        area3: Polygon @search(by: [polygon])
        branches1: MultiPolygon @search
        branches2: MultiPolygon
        branches3: MultiPolygon @search(by: [multiPolygon])
      }
    output: |
      type Hotel {
        Hotel.name
        Hotel.location
        Hotel.landmark
        Hotel.office
        Hotel.area1
        Hotel.area2
        Hotel.area3
        Hotel.branches1
        Hotel.branches2
        Hotel.branches3
      }
      Hotel.name: string .
      Hotel.location: geo @index(geo) .
      Hotel.landmark: geo .
      Hotel.office: geo @index(geo) .
      Hotel.area1: geo @index(geo) .
      Hotel.area2: geo .
      Hotel.area3: geo @index(geo) .
      Hotel.branches1: geo @index(geo) .
      Hotel.branches2: geo .
      Hotel.branches3: geo @index(geo) .

  - name: "Int field with @id Directive"
    input: |
      type T {
        id : Int! @id
        value: String
      }
    output: |
      type T {
        T.id
        T.value
      }
      T.id: int @index(int) @upsert .
      T.value: string .

  - name: "Int64 field with @id Directive"
    input: |
      type T {
        id : Int64! @id
        value: String
      }
    output: |
      type T {
        T.id
        T.value
      }
      T.id: int @index(int) @upsert .
      T.value: string .

  - name: "type extension having @external field of ID type which is @key"
    input: |
      extend type Product @key(fields: "id") {
        id: ID! @external
        name: String!
        price: Int @external
        reviews: [String]
      }
    output: |
      type Product {
        Product.id
        Product.name
        Product.reviews
      }
      Product.id: string @index(hash) @upsert .
      Product.name: string .
      Product.reviews: [string] .

  - name: "type extension having @external field of non ID type which is @key"
    input: |
      extend type Product @key(fields: "name") {
        id: ID! @external
        name: String! @id @external
        reviews: [String]
      }
    output: |
      type Product {
        Product.name
        Product.reviews
      }
      Product.name: string @index(hash) @upsert .
      Product.reviews: [string] .

  - name: "A full valid federation schema"
    input: |
      type Review {
        body: String
        author: User @provides(fields: "username")
        product: Product
      }

      extend type User @key(fields: "id") {
        id: ID! @external
        username: String! @external
        reviews: [Review]
      }

      type Product @key(fields: "upc") @extends {
        upc: String! @id @external
        weight: Int @external
        price: Int @external
        inStock: Boolean
        shippingEstimate: Int @requires(fields: "price weight") @lambda
        reviews: [Review]
      }
    output: |
      type Review {
        Review.body
        Review.author
        Review.product
      }
      Review.body: string .
      Review.author: uid .
      Review.product: uid .
      type Product {
        Product.upc
        Product.inStock
        Product.reviews
      }
      Product.upc: string @index(hash) @upsert .
      Product.inStock: bool .
      Product.reviews: [uid] .
      type User {
        User.id
        User.username
        User.reviews
      }
      User.id: string @index(hash) @upsert .
      User.username: string .
      User.reviews: [uid] .

  - name: "nothing is added in dgraph schema with lambdaOnMutate"
    input: |
      type T @lambdaOnMutate(add: true, update: true, delete: true) {
        id : ID!
        value: String
      }
    output: |
      type T {
        T.value
      }
      T.value: string .