schema.graphql

directive @goField(
  forceResolver: Boolean
  name: String
) on INPUT_FIELD_DEFINITION | FIELD_DEFINITION

directive @isAuthenticated(userType: UserType!) on FIELD_DEFINITION

directive @meta(
  validate: String
) on OBJECT | FIELD_DEFINITION | ENUM_VALUE | INPUT_FIELD_DEFINITION | ENUM | INPUT_OBJECT | ARGUMENT_DEFINITION

input AcceptInvitation {
  token: String!
  password: String!
  firstname: String
  lastname: String
}

type Availability {
  id: ID!
  place: String!
  startTime: Time!
  endTime: Time!
  createdAt: Time!
  updatedAt: Time!
  creator: CompanyUser
  match: Match!
  company: Company!
}

type AvailabilityConnection {
  totalCount: Int!
  pageInfo: PageInfo!
  edges: [AvailabilityEdge]
}

type AvailabilityEdge {
  node: Availability!
  cursor: Cursor!
}

type Booking {
  id: ID!
  startTime: Time!
  endTime: Time!
  availability: Availability!
  description: String
  confirmed: Boolean!
  rejected: Boolean!
  createdAt: Time!
  updatedAt: Time!
}

type BookingConnection {
  totalCount: Int!
  pageInfo: PageInfo!
  edges: [BookingEdge]
}

type BookingEdge {
  node: Booking!
  cursor: Cursor!
}

type Comment {
  id: ID!
  content: String!
  match: Match!
  author: CompanyUser!
  createdAt: Time!
  updatedAt: Time!
}

type CommentConnection {
  totalCount: Int!
  pageInfo: PageInfo!
  edges: [CommentEdge]
}

type CommentEdge {
  node: Comment!
  cursor: Cursor!
}

type Company implements Node {
  id: ID!
  name: String!
  siret: String!
  createdAt: Time!
  updatedAt: Time!
  members(
    after: Cursor
    first: Int
    before: Cursor
    last: Int
  ): CompanyUserConnection
  teams(after: Cursor, first: Int, before: Cursor, last: Int): TeamConnection
  invitations(
    after: Cursor
    first: Int
    before: Cursor
    last: Int
  ): InvitationConnection
  offers(after: Cursor, first: Int, before: Cursor, last: Int): OfferConnection
}

type CompanyConnection {
  totalCount: Int!
  pageInfo: PageInfo!
  edges: [CompanyEdge]
}

type CompanyEdge {
  node: Company!
  cursor: Cursor!
}

input CompanyLoginArgs {
  email: String!
  password: String!
}

type CompanyLoginResponse {
  token: String!
  refreshToken: String!
}

type CompanyUser implements Node {
  id: ID!
  email: String!
  lastname: String
  firstname: String
  emailVerified: Boolean!
  createdAt: Time!
  updatedAt: Time!
}

type CompanyUserConnection {
  totalCount: Int!
  pageInfo: PageInfo!
  edges: [CompanyUserEdge]
}

type CompanyUserEdge {
  node: CompanyUser!
  cursor: Cursor!
}

type Competency implements Node {
  id: ID!
  label: String!
  description: String
  broaderId: String
  externalId: String!
  parentId: ID
  createdAt: Time!
  updatedAt: Time!
}

enum ContractType {
  INTERNSHIP
  FIXED
  PERMANENT
}

input CreateAvailability {
  matchID: ID!
  place: String
  startTime: Time!
  endTime: Time!
}

input CreateBooking {
  availabilityID: ID!
}

input CreateComment {
  matchID: ID!
  content: String!
}

input CreateCompany {
  name: String!
  firstname: String
  lastname: String
  email: String!
  password: String!
  siret: String!
  members: [CreateCompanyMember!]
}

input CreateCompanyMember {
  firstname: String
  lastname: String
  email: String!
}

input CreateCompetency {
  label: String!
  description: String!
  parentId: ID
  externalId: String!
  broaderId: String
}

input CreateFeedback {
  matchID: ID!
  rating: Int!
  comment: String
}

input CreateInvitation {
  email: String!
  firstname: String
  lastname: String
}

input CreateOffer {
  name: String!
  description: String!
  maxSalary: Float
  longitude: Float
  latitude: Float
  skills: [CreateSkill!]
  contractTypes: [ContractType!]
  primaryCompetencies: [String!]
  secondaryCompetencies: [String!]
}

input CreateProject {
  name: String!
  minimumSalary: Float
  longitude: Float
  latitude: Float
  skills: [CreateSkill!]
  primaryCompetencies: [String!]
  secondaryCompetencies: [String!]
  contractTypes: [ContractType!]
}

input CreateSkill {
  competencyID: ID!
  level: SkillLevel!
  primary: Boolean!
}

input CreateTeam {
  name: String!
  companyID: ID!
}

input CreateUser {
  email: String!
  password: String!
  pushToken: String
  lastname: String
  firstname: String
  birthdate: Time
}

scalar Cursor

type Feedback {
  id: ID!
  rating: Int!
  comment: String
  match: Match!
  companyUser: CompanyUser!
  createdAt: Time!
  updatedAt: Time!
}

type FeedbackConnection {
  totalCount: Int!
  pageInfo: PageInfo!
  edges: [FeedbackEdge]
}

type FeedbackEdge {
  node: Feedback!
  cursor: Cursor!
}

type Invitation implements Node {
  id: ID!
  firstname: String
  lastname: String
  email: String!
  updatedAt: Time!
  createdAt: Time!
  from: CompanyUser!
  company: Company!
}

type InvitationConnection {
  totalCount: Int!
  pageInfo: PageInfo!
  edges: [InvitationEdge]
}

type InvitationEdge {
  node: Invitation!
  cursor: Cursor!
}

input InviteCompanyUser {
  email: String!
  firstname: String
  lastname: String
}

input LoginArgs {
  email: String!
  password: String!
  pushToken: String
}

type LoginResponse {
  token: String!
  refreshToken: String!
}

type Match implements Node {
  id: ID!
  offer: Offer!
  project: Project!
  status: MatchStatus!
  unread: Boolean!
  pending: Boolean!
  booked: Boolean!
  veto(
    after: Cursor
    first: Int
    before: Cursor
    last: Int
  ): CompanyUserConnection
  feedbacks(
    after: Cursor
    first: Int
    before: Cursor
    last: Int
  ): FeedbackConnection
  comments(
    after: Cursor
    first: Int
    before: Cursor
    last: Int
  ): CommentConnection
  availabilities(
    after: Cursor
    first: Int
    before: Cursor
    last: Int
  ): AvailabilityConnection
  bookings(
    after: Cursor
    first: Int
    before: Cursor
    last: Int
  ): BookingConnection
  percentage: Float!
  updatedAt: Time!
  createdAt: Time!
  deletedAt: Time
}

type MatchConnection {
  totalCount: Int!
  pageInfo: PageInfo!
  edges: [MatchEdge]
}

type MatchEdge {
  node: Match!
  cursor: Cursor!
}

enum MatchStatus {
  MATCHED
  ACCEPTED
  REFUSED
  COMPLETED
  REJECTED
}

type Mutation {
  _empty: String!
  createFeedback(input: CreateFeedback!): Feedback!
  updateFeedback(id: ID!, input: UpdateFeedback!): Feedback!
  deleteFeedback(id: ID!): Boolean!
  createAvailability(input: CreateAvailability): Availability!
  updateAvailability(id: ID!, input: UpdateAvailability): Availability!
  deleteAvailability(id: ID!): Boolean!
  createBooking(input: CreateBooking): Booking!
  updateBooking(id: ID!, input: UpdateBooking): Booking!
  deleteBooking(id: ID!): Boolean!
  createComment(input: CreateComment!): Comment!
  updateComment(id: ID!, input: UpdateComment!): Comment!
  deleteComment(id: ID!): Boolean!
  createCompany(input: CreateCompany!): Company!
  updateCompany(id: ID!, input: UpdateCompany!): Company!
  deleteCompany(id: ID!): Boolean!
  companyLogin(input: CompanyLoginArgs!): CompanyLoginResponse!
  deleteCompanyUser(id: ID!): Boolean!
  createCompetency(input: CreateCompetency!): Competency!
  updateCompetency(id: ID!, input: UpdateCompetency!): Competency!
  deleteCompetency(id: ID!): Boolean!
  createInvitation(input: CreateInvitation!): Invitation!
  updateInvitation(id: ID!, input: UpdateInvitation!): Invitation!
  deleteInvitation(id: ID!): Boolean!
  acceptInvitation(id: ID!, input: AcceptInvitation!): CompanyUser!
  addMatchVeto(id: ID!): Match!
  removeMatchVeto(id: ID!): Match!
  readMatches(ids: [ID!]!): Boolean!
  acceptMatch(id: ID!): Match!
  refuseMatch(id: ID!): Match!
  createOffer(input: CreateOffer!): Offer!
  updateOffer(id: ID!, input: UpdateOffer): Offer!
  deleteOffer(id: ID!): Boolean!
  updateUserPermissions(userId: ID!, input: [PermissionInput]!): Boolean!
  createProject(input: CreateProject): Project!
  updateProject(id: ID!, input: UpdateProject): Project!
  deleteProject(id: ID!): Boolean!
  updateUserRole(userId: ID!, input: UpdateUserRole!): Role!
  updateSkill(id: ID!, input: UpdateSkill!): Skill!
  deleteSkill(id: ID!): Boolean!
  createTeam(input: CreateTeam!): Team!
  updateTeam(id: ID!, input: UpdateTeam!): Team!
  addCompanyUserToTeam(id: ID!, userID: ID!): Team!
  removeCompanyUserFromTeam(id: ID!, userID: ID!): Team!
  deleteTeam(id: ID!): Boolean!
  login(input: LoginArgs!): LoginResponse!
  createUser(input: CreateUser!): User!
  updateUser(id: ID!, input: UpdateUser!): User!
}

interface Node {
  id: ID!
}

type Offer implements Node {
  id: ID!
  name: String!
  description: String!
  maxSalary: Float
  longitude: Float
  latitude: Float
  contractTypes: [ContractType!]!
  createdAt: Time!
  updatedAt: Time!
  skills(after: Cursor, first: Int, before: Cursor, last: Int): SkillConnection
  primaryCompetencies: [String!]
  secondaryCompetencies: [String!]
  company: Company!
}

type OfferConnection {
  totalCount: Int!
  pageInfo: PageInfo!
  edges: [OfferEdge]
}

type OfferEdge {
  node: Offer!
  cursor: Cursor!
}

enum OrderDirection {
  ASC
  DESC
}

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

type Permission implements Node {
  id: ID!
  type: PermissionType!
  user: User
  permissions: [String]
}

type PermissionConnection {
  totalCount: Int!
  pageInfo: PageInfo!
  edges: [PermissionEdge]
}

type PermissionEdge {
  node: Permission!
  cursor: Cursor!
}

input PermissionInput {
  type: PermissionType!
  permissions: [String!]
}

enum PermissionType {
  USER
  TEAM
  OFFER
  CANDIDATE
}

type Project implements Node {
  id: ID!
  name: String!
  minimumSalary: Float
  longitude: Float
  latitude: Float
  skills(after: Cursor, first: Int, before: Cursor, last: Int): SkillConnection
  primaryCompetencies: [String!]
  secondaryCompetencies: [String!]
  contractTypes: [ContractType!]!
  createdAt: Time!
  updatedAt: Time!
}

type Query {
  _empty: String!
  availability(id: ID!): Availability!
  availabilities(
    matchID: ID
    after: Cursor
    first: Int
    before: Cursor
    last: Int
  ): AvailabilityConnection
  bookingByMatchID(matchID: ID!): Booking!
  booking(id: ID!): Booking!
  bookings(
    confirmed: Boolean
    rejected: Boolean
    after: Cursor
    first: Int
    before: Cursor
    last: Int
  ): BookingConnection
  companies(
    after: Cursor
    first: Int
    before: Cursor
    last: Int
  ): CompanyConnection
  company: Company!
  companyByID(id: ID!): Company!
  companyUser(id: ID): CompanyUser!
  competency(id: ID!): Competency!
  competencies(searchValue: String!): [Competency]!
  competenciesFromParent(parentId: ID!): [Competency]!
  parentCompetencies: [Competency]!
  invitation(id: ID!): Invitation
  match(id: ID!): Match!
  matches(
    after: Cursor
    first: Int
    before: Cursor
    last: Int
    status: MatchStatus
    recentlyDeleted: Boolean
    unread: Boolean
  ): MatchConnection
  offer(id: ID!): Offer!
  offers(after: Cursor, first: Int, before: Cursor, last: Int): OfferConnection
  getUserPermissions(userId: ID!): [Permission]!
  project(id: ID!): Project!
  projects: [Project!]
  getUserRole(userId: ID!): Role!
  teams(after: Cursor, first: Int, before: Cursor, last: Int): TeamConnection
  team(id: ID!): Team!
  user: User!
}

type Role implements Node {
  id: ID!
  role: RoleValue!
}

type RoleConnection {
  totalCount: Int!
  pageInfo: PageInfo!
  edges: [Role]
}

type RoleEdge {
  node: Role!
  cursor: Cursor!
}

enum RoleValue {
  ADMIN
  RECRUITER
  REVIEWER
}

type Skill implements Node {
  id: ID!
  level: SkillLevel!
  primary: Boolean!
  competency: Competency!
  offer: Offer
  project: Project
}

type SkillConnection {
  totalCount: Int!
  pageInfo: PageInfo!
  edges: [SkillEdge]
}

type SkillEdge {
  node: Skill!
  cursor: Cursor!
}

enum SkillLevel {
  JUNIOR
  INTERMEDIATE
  SENIOR
}

type Subscription {
  matchesUpdated: Match!
}

type Team implements Node {
  id: ID!
  company: Company!
  creator: CompanyUser!
  users(
    after: Cursor
    first: Int
    before: Cursor
    last: Int
  ): CompanyUserConnection
  name: String!
  createdAt: Time!
  updatedAt: Time!
}

type TeamConnection {
  totalCount: Int!
  pageInfo: PageInfo!
  edges: [TeamEdge]
}

type TeamEdge {
  node: Team!
  cursor: Cursor!
}

scalar Time

input UpdateAvailability {
  place: String
  startTime: Time
  endTime: Time
}

input UpdateBooking {
  confirmed: Boolean
  rejected: Boolean
  description: String
}

input UpdateComment {
  content: String
}

input UpdateCompany {
  name: String
  siret: String
}

input UpdateCompetency {
  label: String!
  description: String!
  parentId: ID
}

input UpdateFeedback {
  rating: Int
  comment: String
}

input UpdateInvitation {
  firstname: String
  lastname: String
}

input UpdateOffer {
  name: String
  description: String
  maxSalary: Float
  longitude: Float
  latitude: Float
  skills: [CreateSkill!]
  contractTypes: [ContractType!]
  primaryCompetencies: [String!]
  secondaryCompetencies: [String!]
}

input UpdateProject {
  name: String
  minimumSalary: Float
  longitude: Float
  latitude: Float
  skills: [CreateSkill!]
  primaryCompetencies: [String!]
  secondaryCompetencies: [String!]
  contractTypes: [ContractType!]
}

input UpdateSkill {
  level: SkillLevel
  primary: Boolean
}

input UpdateTeam {
  name: String!
}

input UpdateUser {
  firstname: String
  lastname: String
  birthdate: Time
  pushToken: String
}

input UpdateUserRole {
  role: RoleValue!
}

scalar Upload

type User implements Node {
  id: ID!
  email: String!
  lastname: String
  firstname: String
  birthdate: Time
  emailVerified: Boolean!
  createdAt: Time!
  updatedAt: Time!
  verified: Boolean!
}

enum UserType {
  Company
  User
  Both
}