schema.graphql

directive @embedded on OBJECT
directive @collection(name: String!) on OBJECT
directive @index(name: String!) on FIELD_DEFINITION
directive @resolver(
  name: String
  paginated: Boolean! = false
) on FIELD_DEFINITION
directive @relation(name: String) on FIELD_DEFINITION
directive @unique(index: String) on FIELD_DEFINITION
scalar Date

type Event {
  location: Location!
  _id: ID!
  users(
    _size: Int
    _cursor: String
  ): UserPage!
  meta: String
  title: String!
  type: EventTypes
  events(
    _size: Int
    _cursor: String
  ): SingleEventPage!
  _ts: Long!
}

input EventEventsRelation {
  create: [SingleEventInput]
  connect: [ID]
  disconnect: [ID]
}

input EventInput {
  location: EventLocationRelation
  events: EventEventsRelation
  title: String!
  meta: String
  type: EventTypes
  users: EventUsersRelation
}

input EventLocationRelation {
  create: LocationInput
  connect: ID
}

type EventPage {
  data: [Event]!
  after: String
  before: String
}

enum EventTypes {
  Seminar
  Webinar
}

input EventUsersRelation {
  create: [UserInput]
  connect: [ID]
  disconnect: [ID]
}

type Location {
  _id: ID!
  _ts: Long!
  lat: String!
  lng: String!
}

input LocationInput {
  lat: String!
  lng: String!
}

scalar Long

type Mutation {
  updateUser(
    id: ID!
    data: UserInput!
  ): User
  createUser(data: UserInput!): User!
  deleteLocation(id: ID!): Location
  updateSingleEvent(
    id: ID!
    data: SingleEventInput!
  ): SingleEvent
  updateEvent(
    id: ID!
    data: EventInput!
  ): Event
  deleteSingleEvent(id: ID!): SingleEvent
  updateLocation(
    id: ID!
    data: LocationInput!
  ): Location
  createLocation(data: LocationInput!): Location!
  deleteUser(id: ID!): User
  createEvent(data: EventInput!): Event!
  deleteEvent(id: ID!): Event
  createSingleEvent(data: SingleEventInput!): SingleEvent!
}

type Query {
  findEventByID(id: ID!): Event
  findSingleEventByID(id: ID!): SingleEvent
  findLocationByID(id: ID!): Location
  findUserByID(id: ID!): User
}

type SingleEvent {
  _id: ID!
  end: Date
  owner: Event!
  start: Date
  venue: String
  _ts: Long!
}

input SingleEventInput {
  start: Date
  end: Date
  venue: String
  owner: SingleEventOwnerRelation
}

input SingleEventOwnerRelation {
  create: EventInput
  connect: ID
}

type SingleEventPage {
  data: [SingleEvent]!
  after: String
  before: String
}

scalar Time

type User {
  email: String
  _id: ID!
  firstname: String
  lastname: String
  registeredEvents(
    _size: Int
    _cursor: String
  ): EventPage!
  phone: String
  _ts: Long!
}

input UserInput {
  email: String
  phone: String
  firstname: String
  lastname: String
  registeredEvents: UserRegisteredEventsRelation
}

type UserPage {
  data: [User]!
  after: String
  before: String
}

input UserRegisteredEventsRelation {
  create: [EventInput]
  connect: [ID]
  disconnect: [ID]
}