schema.gql

# ------------------------------------------------------
# THIS FILE WAS AUTOMATICALLY GENERATED (DO NOT MODIFY)
# ------------------------------------------------------

enum ChangeType {
  DELETE
  NEW
  UPDATE
}

type Chat {
  author: User!
  chatType: ChatType!
  createdAt: String!
  endOfLife: String!
  entityId: ID!
  expiration: Int!
  invitation: String!
  isMember: Boolean!
  messages(first: Int = 10): PaginatedMessages!
  name: String!
  profiles(first: Int = 10, nickname: String, order: QueryOrder = ASC): PaginatedProfiles!
  profilesCount: Int!
  slug: String!
  time: Int!
  updatedAt: String!
}

type ChatChange {
  edge: ChatRedisEntityChangeEdge!
  type: ChangeType!
}

type ChatMessage {
  body: String!
  chat: Chat!
  createdAt: String!
  endOfLife: String!
  entityId: ID!
  expiration: Int!
  profile: Profile!
  time: Int!
  updatedAt: String!
}

type ChatMessageRedisEntityChangeEdge {
  cursor: String!
  node: ChatMessage!
}

type ChatMessageRedisEntityPageEdge {
  cursor: String!
  node: ChatMessage!
}

type ChatRedisEntityChangeEdge {
  cursor: String!
  node: Chat!
}

type ChatRedisEntityPageEdge {
  cursor: String!
  node: Chat!
}

enum ChatType {
  PRIVATE
  PUBLIC
}

input CreateChatInput {
  chatType: ChatType!
  name: String!
  time: Int!
}

input CreateInviteInput {
  invitation: String!
  recipientId: String!
}

input CreateMessageInput {
  body: String!
  chatId: String!
}

type Invite {
  chat: Chat!
  createdAt: String!
  entityId: ID!
  invitation: String!
  recipient: User!
  sender: User!
  status: InviteStatus!
  time: Int!
  updatedAt: String!
}

type InviteChange {
  edge: InviteRedisEntityChangeEdge!
  type: ChangeType!
}

type InviteRedisEntityChangeEdge {
  cursor: String!
  node: Invite!
}

type InviteRedisEntityPageEdge {
  cursor: String!
  node: Invite!
}

enum InviteStatus {
  ACCEPTED
  DECLINED
  PENDING
}

type Message {
  id: ID!
  message: String!
}

type MessageChange {
  edge: ChatMessageRedisEntityChangeEdge!
  type: ChangeType!
}

type Mutation {
  acceptInvite(invitation: String!): Invite!
  createChat(input: CreateChatInput!): Chat!
  createInvite(input: CreateInviteInput!): Invite!
  createMessage(input: CreateMessageInput!): ChatMessage!
  createProfile(invitation: String!): Profile!
  declineInvite(invitation: String!): Invite!
  deleteAccount(password: String!): Message!
  deleteInvite(inviteId: String!): Message!
  leaveChat(chatId: String!): Message!
  removeChat(chatId: String!): Message!
  removeMessage(chatId: String!, messageId: String!): Message!
  removeProfile(chatId: String!, profileId: String!): Message!
  updateAccountDescription(description: String!): User!
  updateChat(input: UpdateChatInput!): Chat!
  updateMessage(input: UpdateMessageInput!): ChatMessage!
  updateOnlineStatus(defaultStatus: OnlineStatus!): User!
  updateOwnNickname(input: UpdateNicknameInput!): Profile!
  updateProfileNickname(input: UpdateProfileNicknameInput!): Profile!
  updateRejectedInvite(invitation: String!): Invite!
}

enum OnlineStatus {
  BUSY
  DO_NOT_DISTURB
  IDLE
  INVISIBLE
  OFFLINE
  ONLINE
}

type PageInfo {
  endCursor: String!
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String!
}

type PaginatedChats {
  currentCount: Int!
  edges: [ChatRedisEntityPageEdge!]!
  pageInfo: PageInfo!
  previousCount: Int!
}

type PaginatedInvites {
  currentCount: Int!
  edges: [InviteRedisEntityPageEdge!]!
  pageInfo: PageInfo!
  previousCount: Int!
}

type PaginatedMessages {
  currentCount: Int!
  edges: [ChatMessageRedisEntityPageEdge!]!
  pageInfo: PageInfo!
  previousCount: Int!
}

type PaginatedProfiles {
  currentCount: Int!
  edges: [ProfileRedisEntityPageEdge!]!
  pageInfo: PageInfo!
  previousCount: Int!
}

type PaginatedUsers {
  currentCount: Int!
  edges: [UserEntityPageEdge!]!
  pageInfo: PageInfo!
  previousCount: Int!
}

type Profile {
  chat: Chat!
  createdAt: String!
  endOfLife: String!
  entityId: ID!
  expiration: Int!
  nickname: String!
  slug: String!
  time: Int!
  updatedAt: String!
  user: User!
}

type ProfileChange {
  edge: ProfileRedisEntityChangeEdge!
  type: ChangeType!
}

type ProfileRedisEntityChangeEdge {
  cursor: String!
  node: Profile!
}

type ProfileRedisEntityPageEdge {
  cursor: String!
  node: Profile!
}

type Query {
  chatById(chatId: String!): Chat!
  chatByInvitation(invitation: String!): Chat!
  chatBySlug(slug: String!): Chat!
  chatMessages(after: String, chatId: String!, first: Int = 10): PaginatedMessages!
  chatProfiles(after: String, chatId: String!, first: Int = 10, nickname: String): PaginatedProfiles!
  inviteById(inviteId: String!): Invite!
  inviteByInvitation(invitation: String!): Invite!
  me: User!
  memberChats: [Chat!]!
  messageById(chatId: String!, messageId: String!): ChatMessage!
  profileById(chatId: String!, profileId: String!): Profile!
  profileBySlug(chatId: String!, slug: String!): Profile!
  publicChats(after: String, cursor: QueryCursor = DATE, first: Int = 10, order: QueryOrder = DESC, search: String): PaginatedChats!
  receivedInvites(after: String, first: Int = 10, status: InviteStatus): PaginatedInvites!
  sentInviteById(inviteId: String!): Invite!
  sentInviteByInvitation(invitation: String!): Invite!
  sentInvites(after: String, first: Int = 10, status: InviteStatus): PaginatedInvites!
  userById(userId: String!): User!
  userByUsername(username: String!): User!
  userChats: [Chat!]!
  users(after: String, cursor: QueryCursor = DATE, first: Int = 10, order: QueryOrder = DESC, search: String): PaginatedUsers!
}

enum QueryCursor {
  ALPHA
  DATE
}

enum QueryOrder {
  ASC
  DESC
}

type Subscription {
  chatChange(chatId: String!): ChatChange!
  inviteChange: InviteChange!
  messageChange(chatId: String!): MessageChange!
  profileChange(chatId: String!): ProfileChange!
  publicChatChange: ChatChange!
}

input UpdateChatInput {
  chatId: String!
  chatType: ChatType
  name: String
}

input UpdateMessageInput {
  body: String!
  chatId: String!
  messageId: String!
}

input UpdateNicknameInput {
  chatId: String!
  nickname: String!
}

input UpdateProfileNicknameInput {
  chatId: String!
  nickname: String!
  profileId: String!
}

type User {
  createdAt: String!
  defaultStatus: String
  description: String
  email: String
  id: ID!
  lastLogin: String!
  lastOnline: String!
  name: String!
  onlineStatus: OnlineStatus!
  updatedAt: String!
  username: String!
}

type UserEntityPageEdge {
  cursor: String!
  node: User!
}