schema.graphqls

#scalar Date
type Query {
    profileByUserId(id: ID!): User
    friendsByStatus(status: UserStatus): [User]!
    allFriends: [User]!
    #scores: [Score]
    #settingsByUserId(id: Int!): UserSettings

    getLobbies: [Lobby]
    concludeGame: GameStats
}
type Mutation {
    register(input: RegisterInput!): User
    login(input: LoginInput!): User
    logout: Boolean!
    reset(input: ResetInput!): User
    resetWithToken(input: ResetTokenInput!): User
    #updateUserProfile(input: UserSettingsInput!): User
    addFriend(friendId: ID!): [User]
    tutorialFinished: Boolean!

    createLobby(input: LobbyInput!): Lobby
    joinLobbyById(id: ID!): Lobby
    #deleteLobby(id: ID!): Boolean
    updateLobbySettings(input: GameSettingsInput!): Lobby
    #sendLobbyMessage(message: String!): String
    inviteToLobby(input: LobbyInviteInput!): Boolean

    #requestFriendByUserId(id: ID!): ID
    #sendMessageToUserId(input: MessageInput!): Message

    announceStandby: Boolean
    submitGuess(word: String!): GameRound
    playAgain: Boolean
}
type Subscription {
    lobbyList: [Lobby]
    lobby(id: ID!): Lobby
    lobbyInvites: LobbyInvite
    friendsUpdates: User!
    #lobbyChat: Message

    #friendStatus: User # I suggest we use player (and thus add status to the player..)
    #friendRequest: ID # ID instead of User
    #chatMessages: Message

    #lobbyReady: ID # I suggest we use the Lobby ID?
    gameStatus(id: ID!): GameStatus
    opponentGameRound: [GameRound]
}
#--------------------------------------------------
input RegisterInput {
    username: String!
    email: String!
    password: String!
}
input LoginInput {
    username: String!
    password: String!
}
input ResetInput {
    email: String!
}
input ResetTokenInput {
    resetToken: String!
    password: String!
}
input LobbyInviteInput {
    recipientId: ID
    lobbyId: ID!
}
#input UserSettingsInput {
#    avatarID: String!
#    volume: Int!
#    status: UserStatus!
#    # ...
#}

input LobbyInput {
    size: Int!
    name: String!
    gameCategory: GameCategory!
}
input GameSettingsInput {
    gameMode: GameMode!
    amountRounds: Int
    roundTime: Int
    categories: [String]
}

#input MessageInput {
#    userId: ID!
#    message: String!
#}
#--------------------------------------------------
type User {
    id: ID
    username: String
    email: String
    status: UserStatus
}
type Player {
    id: ID
    name: String
    avatarId: String
    lobbyId: String
}
type UserSettings {
    avatarID: String!
    volume: Int!
    status: UserStatus!
    # ...
}
type Score {
    mode: GameMode!
    score: Int!
}

type Lobby {
    id: ID!
    name: String!
    size: Int!
    owner: Player!
    status: LobbyStatus!
    gameCategory: GameCategory!
    gameMode: GameMode!
    categories: [String]
    game: Game!
    players: [Player]
}
type LobbyInvite {
   id: ID
   lobbyId: ID!
   senderId: ID
   recipientId: ID
}
type Game {
    amountRounds: Int
    roundTime: Int
    maxRounds: Int
    maxTime: Int
    # wordCategories: Categories ??? how
}
type GameRound {
    player: Player
    currentRound: Int
    #targetWord: String
    finished: Boolean
    words: [String]
    letterStates: [[LetterState]]
}
type GameStats {
    targetWord: String
    roundsTaken: Int
    timeTaken: String
    score: Int
    ranking: [Player]
}

type Message {
    userId: ID
    message: String
}
#--------------------------------------------------
enum UserStatus {
    ONLINE
    CREATING_LOBBY
    INGAME
    AWAY
    OFFLINE
}
enum GameCategory {
    PVP
    COOP
    SOLO
}
enum GameMode {
    WORDSPP
    SONICFAST
    TIMERESET
    PARTY
    CHALLENGE
    CHAIN
    CLASSIC
    INTIME
    PLAYERVSAI
    ONEWORD
    WORDCOMBINATION
}
enum LobbyStatus {
    OPEN
    FULL
    INGAME
}
enum GameStatus {
    NEW
    SYNCING
    GUESSING
    WAITING
    FINISHED
}
enum LetterState {
    UNKNOWN
    CORRECTPOSITION
    INWORD
    WRONG
}