Is there any way to expand predicates only following with edges that has a specific facet value

Users Dgraph
1

the reason i want to do this is to query a subgraph from the the whole graph according to the time the edge are formed.

for example, every predicates(edges) have a facet named “date”,

"_:Alice" <friend> "_:Bob"  (date=2019-05-02T13:01:09) .
"_:Alice" <mobile> "_:mobie1"  (date=2019-05-02T13:01:09) .
"_:Frank" <mobile> "_:mobie2"  (date=2019-05-02T13:01:09) .
"_:Alice" <mobile> "_:mobie2"  (date=2019-09-02T13:01:09) .

and then eapand edges from node “Alice”, and the expand only following edges that date<“2019-06-06”.
like:

q(func: eq(name,"Alice")){
    expand(@facets( lt(date, "2019-06-06") ))
}

what i want to return is:

q:[
{
  "name": "Alice",
   "friend": {
       "name": "Bob",
       "friend|date" :  "2019-05-02T13:01:09"
      }
   "mobile":{
       "name": "mobile1",
        "mobile|date" :  "2019-05-02T13:01:09"  
   }
}
]

when change date<"2019-06-06" to date<"2019-09-06", the result should be:

q:[
{
  "name": "Alice",
   "friend": {
       "name": "Bob",
       "friend|date" :  "2019-05-02T13:01:09"
      }
   "mobile":[
        {"name": "mobile1",
        "mobile|date" :  "2019-05-02T13:01:09"  },
        {"name": "mobile2",
        "mobile|date" :  "2019-09-02T13:01:09"  }      
   ]
}
]

Can this be implemented or there exist other way to get my goal.
Thanks for anybody who response.
Best.

2 
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "github.com/dgraph-io/dgo/v210"
    "github.com/dgraph-io/dgo/v210/protos/api"
    "google.golang.org/grpc"
)

func main() {
    // Connect to Dgraph
    conn, err := grpc.Dial("localhost:9080", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }
    defer conn.Close()

    dg := dgo.NewDgraphClient(api.NewDgraphClient(conn))

    // Setup schema
    err = setupSchema(dg)
    if err != nil {
        log.Fatalf("Failed to setup schema: %v", err)
    }

    // Insert sample data
    err = insertSampleData(dg)
    if err != nil {
        log.Fatalf("Failed to insert data: %v", err)
    }

    // Query with different date thresholds
    err = querySubgraph(dg, "2019-06-06T00:00:00")
    if err != nil {
        log.Fatalf("Query failed: %v", err)
    }
    err = querySubgraph(dg, "2019-09-06T00:00:00")
    if err != nil {
        log.Fatalf("Query failed: %v", err)
    }
}

func setupSchema(dg *dgo.DgraphClient) error {
    ctx := context.Background()
    op := &api.Operation{
        Schema: `
            name: string @index(exact) .
            friend: [uid] .
            mobile: [uid] .
            friend|date: datetime .
            mobile|date: datetime .
        `,
    }
    return dg.Alter(ctx, op)
}

func insertSampleData(dg *dgo.DgraphClient) error {
    ctx := context.Background()
    txn := dg.NewTxn()
    defer txn.Discard()

    mu := &api.Mutation{
        SetNquads: []byte(`
            _:Alice <name> "Alice" .
            _:Bob <name> "Bob" .
            _:mobile1 <name> "mobile1" .
            _:mobile2 <name> "mobile2" .
            _:Alice <friend> _:Bob (date=2019-05-02T13:01:09) .
            _:Alice <mobile> _:mobile1 (date=2019-05-02T13:01:09) .
            _:Alice <mobile> _:mobile2 (date=2019-09-02T13:01:09) .
        `),
    }
    _, err := txn.Mutate(ctx, mu)
    if err != nil {
        return err
    }
    return txn.Commit(ctx)
}

func querySubgraph(dg *dgo.DgraphClient, dateThreshold string) error {
    ctx := context.Background()
    txn := dg.NewReadOnlyTxn()
    defer txn.Discard()

    query := fmt.Sprintf(`
    {
      q(func: eq(name, "Alice")) {
        name
        friend @facets(date) @filter(lt("date", "%s")) {
          name
          friend|date
        }
        mobile @facets(date) @filter(lt("date", "%s")) {
          name
          mobile|date
        }
      }
    }`, dateThreshold, dateThreshold)

    resp, err := txn.Query(ctx, query)
    if err != nil {
        return fmt.Errorf("query error: %v", err)
    }

    var result map[string]interface{}
    if err := json.Unmarshal(resp.Json, &result); err != nil {
        return fmt.Errorf("unmarshal error: %v", err)
    }
    prettyJSON, _ := json.MarshalIndent(result, "", "  ")
    fmt.Printf("Subgraph for date < %s:\n%s\n\n", dateThreshold, string(prettyJSON))
    return nil
}