schema.gql

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

schema {
  query: Query
  mutation: Mutation
  subscription: Subscription
}

"""
requires authorization

allowed forms:
    - http headers
        - Authorization: Bearer <token>
"""
directive @auth(
  """if resource is not owned by current user field id nulled"""
  onlyOwn: Boolean = false
  optional: Boolean = false
) on FIELD_DEFINITION

"""
requires balance to be high enough
if it's too low returns BalanceTooLowError
"""
directive @balance on FIELD_DEFINITION

directive @constraint(contains: String, endsWith: String, exclusiveMax: Float, exclusiveMin: Float, format: String, max: Float, maxLength: Int, min: Float, minLength: Int, multipleOf: Float, notContains: String, pattern: String, startsWith: String, uniqueTypeName: String) on ARGUMENT_DEFINITION | FIELD_DEFINITION | INPUT_FIELD_DEFINITION

directive @maybeInProgress on FIELD_DEFINITION

type AuthPayload {
  token: AuthTokenEntity!
  user: UserEntity!
}

type AuthTokenEntity {
  createdAt: DateTime!
  expiresAt: DateTime!
  isExpired: Boolean!
  name: String!
  token: String!
}

type BalanceEntity {
  balance: Int!
}

union BalanceEntityOrBalanceTooLowError = BalanceEntity | BalanceTooLowError

type BalanceTooLowError {
  chargeAmount: Int!
  currentBalance: Int!
}

"""
A date-time string at UTC, such as 2019-12-03T09:54:33Z, compliant with the date-time format.
"""
scalar DateTime

type DiceRollEntity {
  amount: Int!
  chances: Int!
  createdAt: DateTime!
  nonce: Int!
  side: DiceRollSide!
  user: UserEntity!
  winning: Int!
  won: Boolean!
}

union DiceRollEntityOrBalanceTooLowError = BalanceTooLowError | DiceRollEntity

input DiceRollInput {
  amount: Int! @constraint(min: 1)
  chances: Int! @constraint(min: 1, exclusiveMax: 100000)
  side: DiceRollSide = LOWER
}

enum DiceRollSide {
  LOWER
  UPPER
}

type DiceSeedEntity {
  clientSeed: String!
  hashedNextServerSeed: String!
  hashedServerSeed: String!
  previousServerSeed: String
}

type InProgressError {
  closedAt: DateTime!
  nextOpenAt: DateTime
}

input LoginInput {
  email: String! @constraint(format: "email")
  password: String!
  tokenName: String!
}

type Mutation {
  deposit(amount: Int!): BalanceEntity! @auth
  login(login: LoginInput!): AuthPayload!
  logout(register: String!): UserToken! @auth
  placeRouletteBet(bet: PlaceRouletteBetInput!): RouletteBetEntityOrBalanceTooLowErrorOrInProgressError @balance @maybeInProgress @auth
  register(register: RegisterInput!): AuthPayload!
  rollDice(createDiceInput: DiceRollInput!): DiceRollEntityOrBalanceTooLowError @balance @auth
  updateDiceSeed(newSeed: String!): DiceSeedEntity! @auth
  updateUser(updateUser: UpdateUserInput!): UserEntity! @auth
  withdraw(amount: Int!): BalanceEntityOrBalanceTooLowError @balance @auth
}

input PageInput {
  skip: Int = 0 @constraint(min: 0)
  take: Int = 10 @constraint(exclusiveMin: 0, max: 20)
}

input PlaceRouletteBetInput {
  amount: Int! @constraint(exclusiveMin: 0)
  color: RouletteBetColor!
}

type Query {
  diceRollHistory(page: PageInput!): [DiceRollEntity!]!
  """either there must be specified id or you must be authenticated"""
  findUser(id: ID): UserEntity! @auth(optional: true)
  rouletteRollHistory(page: PageInput!): [RouletteRollEntity!]!
  rouletteSeedsHistory(page: PageInput!): [RouletteSeedEntity!]!
  rouletteStats: RouletteStatsEntity!
}

input RegisterInput {
  email: String! @constraint(format: "email")
  name: String!
  password: String!
  tokenName: String!
}

enum RouletteBetColor {
  BLACK
  GREEN
  RED
}

type RouletteBetEntity {
  amount: Int!
  color: RouletteBetColor!
  id: ID!
  roll: RouletteRollEntity
}

union RouletteBetEntityOrBalanceTooLowError = BalanceTooLowError | RouletteBetEntity

union RouletteBetEntityOrBalanceTooLowErrorOrInProgressError = BalanceTooLowError | InProgressError | RouletteBetEntity

type RouletteRollEntity {
  color: RouletteBetColor!
  createdAt: DateTime!
  nonce: Int!
  seed: RouletteSeedEntity!
  winning: Int!
}

type RouletteSeedEntity {
  day: DateTime!
  id: ID!
  isHashed: Boolean!
  privateKey: String!
  publicKey: String!
}

type RouletteStatsEntity {
  blackCount: Int!
  greenCount: Int!
  redCount: Int!
}

type Subscription {
  onRouletteResults: RouletteRollEntity!
  onRouletteRoll: ID!
}

input UpdateUserInput {
  email: String @constraint(format: "email")
  name: String
  password: String
}

type UserEntity {
  balance: Int @auth(onlyOwn: true)
  diceRolls(page: PageInput!): [DiceRollEntity!]!
  diceSeed: DiceSeedEntity @auth(onlyOwn: true)
  email: String @auth(onlyOwn: true)
  id: ID!
  name: String!
  rouletteBets(page: PageInput!): [RouletteBetEntity!]!
  tokens: [UserToken!] @auth(onlyOwn: true)
}

type UserToken {
  createdAt: DateTime!
  expiresAt: DateTime!
  isExpired: Boolean!
  name: String!
}