interface-with-id-directive.graphql

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

interface LibraryItem {
	refID: String! @id
}

type Book implements LibraryItem {
	refID: String! @id
	title: String
	author: String
}

type Library {
	items(filter: LibraryItemFilter, order: LibraryItemOrder, first: Int, offset: Int): [LibraryItem]
	itemsAggregate(filter: LibraryItemFilter): LibraryItemAggregateResult
}

#######################
# 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 on FIELD_DEFINITION
directive @withSubscription on OBJECT | INTERFACE
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 @cascade(fields: [String]) on FIELD
directive @lambda on FIELD_DEFINITION
directive @cacheControl(maxAge: Int!) on QUERY
directive @generate(
	query: GenerateQueryParams,
	mutation: GenerateMutationParams,
	subscription: Boolean) on OBJECT | INTERFACE

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

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

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

input DateTimeFilter {
	eq: 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 AddBookPayload {
	book(filter: BookFilter, order: BookOrder, first: Int, offset: Int): [Book]
	numUids: Int
}

type AddLibraryPayload {
	library(filter: LibraryFilter, first: Int, offset: Int): [Library]
	numUids: Int
}

type BookAggregateResult {
	count: Int
	refIDMin: String
	refIDMax: String
	titleMin: String
	titleMax: String
	authorMin: String
	authorMax: String
}

type DeleteBookPayload {
	book(filter: BookFilter, order: BookOrder, first: Int, offset: Int): [Book]
	msg: String
	numUids: Int
}

type DeleteLibraryItemPayload {
	libraryItem(filter: LibraryItemFilter, order: LibraryItemOrder, first: Int, offset: Int): [LibraryItem]
	msg: String
	numUids: Int
}

type DeleteLibraryPayload {
	library(filter: LibraryFilter, first: Int, offset: Int): [Library]
	msg: String
	numUids: Int
}

type LibraryAggregateResult {
	count: Int
}

type LibraryItemAggregateResult {
	count: Int
	refIDMin: String
	refIDMax: String
}

type UpdateBookPayload {
	book(filter: BookFilter, order: BookOrder, first: Int, offset: Int): [Book]
	numUids: Int
}

type UpdateLibraryPayload {
	library(filter: LibraryFilter, first: Int, offset: Int): [Library]
	numUids: Int
}

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

enum BookHasFilter {
	refID
	title
	author
}

enum BookOrderable {
	refID
	title
	author
}

enum LibraryHasFilter {
	items
}

enum LibraryItemHasFilter {
	refID
}

enum LibraryItemOrderable {
	refID
}

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

input AddBookInput {
	refID: String!
	title: String
	author: String
}

input AddLibraryInput {
	items: [LibraryItemRef]
}

input BookFilter {
	refID: StringHashFilter
	has: BookHasFilter
	and: [BookFilter]
	or: [BookFilter]
	not: BookFilter
}

input BookOrder {
	asc: BookOrderable
	desc: BookOrderable
	then: BookOrder
}

input BookPatch {
	title: String
	author: String
}

input BookRef {
	refID: String
	title: String
	author: String
}

input LibraryFilter {
	has: LibraryHasFilter
	and: [LibraryFilter]
	or: [LibraryFilter]
	not: LibraryFilter
}

input LibraryItemFilter {
	refID: StringHashFilter
	has: LibraryItemHasFilter
	and: [LibraryItemFilter]
	or: [LibraryItemFilter]
	not: LibraryItemFilter
}

input LibraryItemOrder {
	asc: LibraryItemOrderable
	desc: LibraryItemOrderable
	then: LibraryItemOrder
}

input LibraryItemRef {
	refID: String! @id
}

input LibraryPatch {
	items: [LibraryItemRef]
}

input LibraryRef {
	items: [LibraryItemRef]
}

input UpdateBookInput {
	filter: BookFilter!
	set: BookPatch
	remove: BookPatch
}

input UpdateLibraryInput {
	filter: LibraryFilter!
	set: LibraryPatch
	remove: LibraryPatch
}

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

type Query {
	getLibraryItem(refID: String!): LibraryItem
	queryLibraryItem(filter: LibraryItemFilter, order: LibraryItemOrder, first: Int, offset: Int): [LibraryItem]
	aggregateLibraryItem(filter: LibraryItemFilter): LibraryItemAggregateResult
	getBook(refID: String!): Book
	queryBook(filter: BookFilter, order: BookOrder, first: Int, offset: Int): [Book]
	aggregateBook(filter: BookFilter): BookAggregateResult
	queryLibrary(filter: LibraryFilter, first: Int, offset: Int): [Library]
	aggregateLibrary(filter: LibraryFilter): LibraryAggregateResult
}

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

type Mutation {
	deleteLibraryItem(filter: LibraryItemFilter!): DeleteLibraryItemPayload
	addBook(input: [AddBookInput!]!): AddBookPayload
	updateBook(input: UpdateBookInput!): UpdateBookPayload
	deleteBook(filter: BookFilter!): DeleteBookPayload
	addLibrary(input: [AddLibraryInput!]!): AddLibraryPayload
	updateLibrary(input: UpdateLibraryInput!): UpdateLibraryPayload
	deleteLibrary(filter: LibraryFilter!): DeleteLibraryPayload
}