custom-dql-query-with-subscription.graphql

#######################
# Input Schema
#######################

type Tweets {
	id: ID!
	text: String! @search(by: [fulltext])
	author(filter: UserFilter): User @hasInverse(field: tweets)
	timestamp: DateTime! @search
}

type User {
	screen_name: String! @id
	followers: Int @search
	tweets(filter: TweetsFilter, order: TweetsOrder, first: Int, offset: Int): [Tweets] @hasInverse(field: author)
	tweetsAggregate(filter: TweetsFilter): TweetsAggregateResult
}

type UserTweetCount @remote {
	screen_name: String
	tweetCount: Int
}

#######################
# Extended Definitions
#######################

"""
The Int64 scalar type represents a signed 64‐bit numeric non‐fractional value.
Int64 can represent values in range [-(2^63),(2^63 - 1)].
"""
scalar Int64

"""
The DateTime scalar type represents date and time as a string in RFC3339 format.
For example: "1985-04-12T23:20:50.52Z" represents 20 minutes and 50.52 seconds after the 23rd hour of April 12th, 1985 in UTC.
"""
scalar DateTime

input IntRange{
	min: Int!
	max: Int!
}

input FloatRange{
	min: Float!
	max: Float!
}

input Int64Range{
	min: Int64!
	max: Int64!
}

input DateTimeRange{
	min: DateTime!
	max: DateTime!
}

input StringRange{
	min: String!
	max: String!
}

enum DgraphIndex {
	int
	int64
	float
	bool
	hash
	exact
	term
	fulltext
	trigram
	regexp
	year
	month
	day
	hour
	geo
}

input AuthRule {
	and: [AuthRule]
	or: [AuthRule]
	not: AuthRule
	rule: String
}

enum HTTPMethod {
	GET
	POST
	PUT
	PATCH
	DELETE
}

enum Mode {
	BATCH
	SINGLE
}

input CustomHTTP {
	url: String!
	method: HTTPMethod!
	body: String
	graphql: String
	mode: Mode
	forwardHeaders: [String!]
	secretHeaders: [String!]
	introspectionHeaders: [String!]
	skipIntrospection: Boolean
}

type Point {
	longitude: Float!
	latitude: Float!
}

input PointRef {
	longitude: Float!
	latitude: Float!
}

input NearFilter {
	distance: Float!
	coordinate: PointRef!
}

input PointGeoFilter {
	near: NearFilter
	within: WithinFilter
}

type PointList {
	points: [Point!]!
}

input PointListRef {
	points: [PointRef!]!
}

type Polygon {
	coordinates: [PointList!]!
}

input PolygonRef {
	coordinates: [PointListRef!]!
}

type MultiPolygon {
	polygons: [Polygon!]!
}

input MultiPolygonRef {
	polygons: [PolygonRef!]!
}

input WithinFilter {
	polygon: PolygonRef!
}

input ContainsFilter {
	point: PointRef
	polygon: PolygonRef
}

input IntersectsFilter {
	polygon: PolygonRef
	multiPolygon: MultiPolygonRef
}

input PolygonGeoFilter {
	near: NearFilter
	within: WithinFilter
	contains: ContainsFilter
	intersects: IntersectsFilter
}

input GenerateQueryParams {
	get: Boolean
	query: Boolean
	password: Boolean
	aggregate: Boolean
}

input GenerateMutationParams {
	add: Boolean
	update: Boolean
	delete: Boolean
}

directive @hasInverse(field: String!) on FIELD_DEFINITION
directive @search(by: [DgraphIndex!]) on FIELD_DEFINITION
directive @dgraph(type: String, pred: String) on OBJECT | INTERFACE | FIELD_DEFINITION
directive @id(interface: Boolean) on FIELD_DEFINITION
directive @withSubscription on OBJECT | INTERFACE | FIELD_DEFINITION
directive @secret(field: String!, pred: String) on OBJECT | INTERFACE
directive @auth(
	password: AuthRule
	query: AuthRule,
	add: AuthRule,
	update: AuthRule,
	delete: AuthRule) on OBJECT | INTERFACE
directive @custom(http: CustomHTTP, dql: String) on FIELD_DEFINITION
directive @remote on OBJECT | INTERFACE | UNION | INPUT_OBJECT | ENUM
directive @remoteResponse(name: String) on FIELD_DEFINITION
directive @cascade(fields: [String]) on FIELD
directive @lambda on FIELD_DEFINITION
directive @lambdaOnMutate(add: Boolean, update: Boolean, delete: Boolean) on OBJECT | INTERFACE
directive @cacheControl(maxAge: Int!) on QUERY
directive @generate(
	query: GenerateQueryParams,
	mutation: GenerateMutationParams,
	subscription: Boolean) on OBJECT | INTERFACE

input IntFilter {
	eq: Int
	in: [Int]
	le: Int
	lt: Int
	ge: Int
	gt: Int
	between: IntRange
}

input Int64Filter {
	eq: Int64
	in: [Int64]
	le: Int64
	lt: Int64
	ge: Int64
	gt: Int64
	between: Int64Range
}

input FloatFilter {
	eq: Float
	in: [Float]
	le: Float
	lt: Float
	ge: Float
	gt: Float
	between: FloatRange
}

input DateTimeFilter {
	eq: DateTime
	in: [DateTime]
	le: DateTime
	lt: DateTime
	ge: DateTime
	gt: DateTime
	between: DateTimeRange
}

input StringTermFilter {
	allofterms: String
	anyofterms: String
}

input StringRegExpFilter {
	regexp: String
}

input StringFullTextFilter {
	alloftext: String
	anyoftext: String
}

input StringExactFilter {
	eq: String
	in: [String]
	le: String
	lt: String
	ge: String
	gt: String
	between: StringRange
}

input StringHashFilter {
	eq: String
	in: [String]
}

#######################
# Generated Types
#######################

type AddTweetsPayload {
	tweets(filter: TweetsFilter, order: TweetsOrder, first: Int, offset: Int): [Tweets]
	numUids: Int
}

type AddUserPayload {
	user(filter: UserFilter, order: UserOrder, first: Int, offset: Int): [User]
	numUids: Int
}

type DeleteTweetsPayload {
	tweets(filter: TweetsFilter, order: TweetsOrder, first: Int, offset: Int): [Tweets]
	msg: String
	numUids: Int
}

type DeleteUserPayload {
	user(filter: UserFilter, order: UserOrder, first: Int, offset: Int): [User]
	msg: String
	numUids: Int
}

type TweetsAggregateResult {
	count: Int
	textMin: String
	textMax: String
	timestampMin: DateTime
	timestampMax: DateTime
}

type UpdateTweetsPayload {
	tweets(filter: TweetsFilter, order: TweetsOrder, first: Int, offset: Int): [Tweets]
	numUids: Int
}

type UpdateUserPayload {
	user(filter: UserFilter, order: UserOrder, first: Int, offset: Int): [User]
	numUids: Int
}

type UserAggregateResult {
	count: Int
	screen_nameMin: String
	screen_nameMax: String
	followersMin: Int
	followersMax: Int
	followersSum: Int
	followersAvg: Float
}

#######################
# Generated Enums
#######################

enum TweetsHasFilter {
	text
	author
	timestamp
}

enum TweetsOrderable {
	text
	timestamp
}

enum UserHasFilter {
	screen_name
	followers
	tweets
}

enum UserOrderable {
	screen_name
	followers
}

#######################
# Generated Inputs
#######################

input AddTweetsInput {
	text: String!
	author: UserRef
	timestamp: DateTime!
}

input AddUserInput {
	screen_name: String!
	followers: Int
	tweets: [TweetsRef]
}

input TweetsFilter {
	id: [ID!]
	text: StringFullTextFilter
	timestamp: DateTimeFilter
	has: [TweetsHasFilter]
	and: [TweetsFilter]
	or: [TweetsFilter]
	not: TweetsFilter
}

input TweetsOrder {
	asc: TweetsOrderable
	desc: TweetsOrderable
	then: TweetsOrder
}

input TweetsPatch {
	text: String
	author: UserRef
	timestamp: DateTime
}

input TweetsRef {
	id: ID
	text: String
	author: UserRef
	timestamp: DateTime
}

input UpdateTweetsInput {
	filter: TweetsFilter!
	set: TweetsPatch
	remove: TweetsPatch
}

input UpdateUserInput {
	filter: UserFilter!
	set: UserPatch
	remove: UserPatch
}

input UserFilter {
	screen_name: StringHashFilter
	followers: IntFilter
	has: [UserHasFilter]
	and: [UserFilter]
	or: [UserFilter]
	not: UserFilter
}

input UserOrder {
	asc: UserOrderable
	desc: UserOrderable
	then: UserOrder
}

input UserPatch {
	screen_name: String
	followers: Int
	tweets: [TweetsRef]
}

input UserRef {
	screen_name: String
	followers: Int
	tweets: [TweetsRef]
}

#######################
# Generated Query
#######################

type Query {
	queryUserTweetCounts: [UserTweetCount] @withSubscription @custom(dql: "query {\n    queryUserTweetCounts(func: type(User)) {\n        screen_name: User.screen_name\n        tweetCount: count(User.tweets)\n    }\n}")
	getTweets(id: ID!): Tweets
	queryTweets(filter: TweetsFilter, order: TweetsOrder, first: Int, offset: Int): [Tweets]
	aggregateTweets(filter: TweetsFilter): TweetsAggregateResult
	getUser(screen_name: String!): User
	queryUser(filter: UserFilter, order: UserOrder, first: Int, offset: Int): [User]
	aggregateUser(filter: UserFilter): UserAggregateResult
}

#######################
# Generated Mutations
#######################

type Mutation {
	addTweets(input: [AddTweetsInput!]!): AddTweetsPayload
	updateTweets(input: UpdateTweetsInput!): UpdateTweetsPayload
	deleteTweets(filter: TweetsFilter!): DeleteTweetsPayload
	addUser(input: [AddUserInput!]!, upsert: Boolean): AddUserPayload
	updateUser(input: UpdateUserInput!): UpdateUserPayload
	deleteUser(filter: UserFilter!): DeleteUserPayload
}

#######################
# Generated Subscriptions
#######################

type Subscription {
	queryUserTweetCounts: [UserTweetCount] @withSubscription @custom(dql: "query {\n    queryUserTweetCounts(func: type(User)) {\n        screen_name: User.screen_name\n        tweetCount: count(User.tweets)\n    }\n}")
}