schema.graphql

"""Exposes a URL that specifies the behaviour of this scalar."""
directive @specifiedBy(
  """The URL that specifies the behaviour of this scalar."""
  url: String!
) on SCALAR

"""요청된 작업에 admin 권한이 필요하나, 권한을 가지고 있지 않은 경우"""
type AdminPermissionRequiredError {
  message: String!
}

"""이미 멤버쉽에 가입 되어 있으나 다시 멤버쉽 가입을 요청한 경우 발생"""
type AlreadyJoinedMembershipError {
  message: String!
}

"""로그인한 사용자는 접근할 수 없는 서비스에 접근한 경우"""
type AnonymousOnlyError {
  message: String!
}

"""Authentication에 필요한 정보가 전달되지 않았을 때 발생하는 에러"""
type AuthInfoRequiredError {
  message: String!
}

"""작성자 검색 인터페이스"""
input AuthorFilter {
  """작성자 페르소나의 ID"""
  id: GlobalID!
}

"""일정 생년 구간의 데이터를 받아 오기 위한 인터페이스"""
input BirthYearFilter {
  """최소 생년"""
  minBirthYear: Int = 0

  """최대 생년"""
  maxBirthYear: Int = 100
}

type Bookmark implements Node {
  id: GlobalID!

  """대상 페르소나"""
  persona: Persona!

  """대상 게시물"""
  post: Post!

  """북마크 일시"""
  createdAt: DateTime!
}

"""
Post가 소속되거나, Persona의 선호 대상이 되는 카테고리
- Post : Category = N : 1
- Persona : Category = N : M
"""
type Category implements Node {
  id: GlobalID!

  """카테고리 본문"""
  body: String!

  """생성 일시"""
  createdAt: DateTime!
}

"""이미 등록된 body로 카테고리 생성을 시도한 경우 발생"""
type CategoryBodyDuplicatedError {
  """중복 필드 이름"""
  violatedFieldName: String!

  """중복된 카테고리 body 값"""
  violatedFieldValue: String!
  message: String!
}

"""카테고리 검색 인터페이스"""
input CategoryBodyFilter {
  """검색 모드"""
  mode: StringFindMode = EXACTLY

  """검색 문자열"""
  token: String!
}

"""카테고리 body의 길이가 기준치보다 긴 경우 발생"""
type CategoryBodyTooLongError {
  """위반 필드 값"""
  violatedFieldName: String!

  """위반 사유 상세"""
  detail: String
  message: String!

  """전달된 카테고리 body 값"""
  violatedFieldValue: String!
}

"""카테고리 body의 길이가 기준치보다 짧은 경우 발생"""
type CategoryBodyTooShortError {
  """위반 필드 값"""
  violatedFieldName: String!

  """위반 사유 상세"""
  detail: String
  message: String!

  """전달된 카테고리 body 값"""
  violatedFieldValue: String!
}

"""A connection to a list of items."""
type CategoryConnection {
  """Pagination data for this connection"""
  pageInfo: PageInfo!

  """Contains the nodes in this connection"""
  edges: [CategoryEdge!]!

  """Total quantity of existing nodes"""
  totalCount: Int
}

"""An edge in a connection."""
type CategoryEdge {
  """A cursor for use in pagination"""
  cursor: String!

  """The item at the end of the edge"""
  node: Category!
}

"""카테고리 검색 인터페이스"""
input CategoryFilter {
  """검색할 카테고리의 ID"""
  id: GlobalID!
}

input CategoryIDInput {
  """카테고리 ID"""
  id: GlobalID!
}

"""카테고리 정렬 기준"""
enum CategorySortBy {
  ID
  LEXICOGRAPHICAL
  CREATED_AT

  """선호 페르소나 수 기준"""
  PERSONA_REFERENCE_CNT

  """연결된 게시물 수 기준"""
  POST_CONNECTION_CNT
}

"""카테고리 목록 조회 시 적용할 정렬 방법"""
input CategorySortingOption {
  """정렬 기준"""
  sortBy: CategorySortBy = ID

  """정렬 방향"""
  direction: SortingDirection = ASC
}

type Challenge implements Node {
  id: GlobalID!

  """제목"""
  title: String!

  """생성 일시"""
  createdAt: DateTime!

  """갱신 일시"""
  updatedAt: DateTime!
}

"""A connection to a list of items."""
type ChallengeConnection {
  """Pagination data for this connection"""
  pageInfo: PageInfo!

  """Contains the nodes in this connection"""
  edges: [ChallengeEdge!]!

  """Total quantity of existing nodes"""
  totalCount: Int
}

"""An edge in a connection."""
type ChallengeEdge {
  """A cursor for use in pagination"""
  cursor: String!

  """The item at the end of the edge"""
  node: Challenge!
}

type ChallengeObjective implements Node {
  id: GlobalID!

  """도전과제"""
  challenge: Challenge!

  """제목"""
  title: String!

  """내용"""
  content: String!

  """완수 여부"""
  isDone: Boolean!

  """생성 일시"""
  createdAt: DateTime!

  """갱신 일시"""
  updatedAt: DateTime!
}

"""A connection to a list of items."""
type ChallengeObjectiveConnection {
  """Pagination data for this connection"""
  pageInfo: PageInfo!

  """Contains the nodes in this connection"""
  edges: [ChallengeObjectiveEdge!]!

  """Total quantity of existing nodes"""
  totalCount: Int
}

"""An edge in a connection."""
type ChallengeObjectiveEdge {
  """A cursor for use in pagination"""
  cursor: String!

  """The item at the end of the edge"""
  node: ChallengeObjective!
}

type ChallengeObjectiveHistory implements Node {
  id: GlobalID!

  """도전과제"""
  challengeObjective: ChallengeObjective!

  """참여 페르소나"""
  persona: Persona!

  """완료 여부"""
  isDone: Boolean!

  """참여 일시"""
  createdAt: DateTime!
}

type Comment implements Node {
  id: GlobalID!

  """대상 게시물"""
  post: Post!

  """작성자"""
  persona: Persona!

  """댓글 본문"""
  body: String!

  """작성 일시"""
  createdAt: DateTime!
}

"""항목별 개수 통계"""
type CountStatistics {
  """단위"""
  unit: String!

  """총 개수"""
  totalCount: Int!

  """단위별 항목 개수"""
  elements: [CountStatisticsElement!]!
}

"""특정 항목의 이름 및 개수"""
type CountStatisticsElement {
  """항목 이름"""
  label: String!

  """항목 집계 횟수"""
  count: Int!
}

union CreateCategoryResult = Category | AdminPermissionRequiredError | CategoryBodyDuplicatedError | CategoryBodyTooShortError | CategoryBodyTooLongError

input CreateChallengeInput {
  title: String!
  description: String!
  maxPersonaCount: Int!
}

input CreateChallengeObjectiveInput {
  title: String!
  description: String!
  challenge: GlobalID!
  durationType: DurationType!
  kind: ParticipateKind!
}

union CreatePersonaResult = Persona | AuthInfoRequiredError | PersonaNicknameDuplicatedError

"""게시물 생성 input"""
input CreatePostInput {
  """새 게시글 제목"""
  title: String!

  """새 게시글 무료 본문"""
  content: String!

  """새 게시글 유료 본문"""
  paidContent: String = null

  """연결할 태그의 body 목록 (insert 됨)"""
  tagBodies: [String!] = []

  """소속 카테고리"""
  category: NodeInput
}

union CreatePostResult = Post | AuthInfoRequiredError | ResourceNotFoundError

"""Date with time (isoformat)"""
scalar DateTime

"""특정 날짜/시각 사이의 범위에 해당되는 데이터를 받아 오기 위한 인터페이스"""
input DatetimeBetween {
  """조회 시작 일시"""
  startDt: DateTime = null

  """조회 종료 일시"""
  endDt: DateTime = "2023-05-18T20:28:49.186711"
}

enum DurationType {
  MONTHLY
  DAILY
  WEEKLY
}

"""이미 사용 중인 email로 생성/수정을 시도하려는 경우"""
type EmailAlreadyUsedError {
  """중복 필드 이름"""
  violatedFieldName: String!

  """중복된 email 값"""
  violatedFieldValue: String!
  message: String!
}

"""특정 항목의 점수를 표시하기 위한 타입"""
type FieldScore {
  """항목의 이름"""
  label: String!

  """점수"""
  score: Int!
}

enum Gender {
  MALE
  FEMALE
}

"""성별 검색 인터페이스"""
input GenderFilter {
  """검색할 성별"""
  gender: Gender!
}

input GetFollowingPersonaStatisticsInput {
  """응답될 항목의 최대 개수"""
  resultLimit: Int = 100
}

enum GetMembershipAs {
  """구독자로서 조회"""
  SUBSCRIBER

  """창작자로서 조회"""
  CREATOR
}

"""요청한 사용자가 읽은 게시물에 대한 통계를 내기 위한 입력"""
input GetOwnReadPostStatisticsInput {
  """응답될 항목의 최대 개수"""
  resultLimit: Int = 100

  """조회 기록 날짜 범위"""
  datetimeBetween: StatisticsDatetimeBetween!
}

input GetPersonaFollowerStatisticsInput {
  """조회 대상 페르소나의 ID"""
  personaId: GlobalID!

  """응답될 항목의 최대 개수"""
  resultLimit: Int = 100
}

"""
The `ID` scalar type represents a unique identifier, often used to refetch an
object or as key for a cache. The ID type appears in a JSON response as a
String; however, it is not intended to be human-readable. When expected as an
input type, any string (such as `"4"`) or integer (such as `4`) input value will
be accepted as an ID.
"""
scalar GlobalID

"""사용자 목록 | signup method"""
enum GraphqlAppUserSignupMethodEnum {
  EM
}

type ImageUploadUrl {
  url: String!
  fields: JSON!
}

"""공인 여부 검색 인터페이스"""
input IsCertifiedFilter {
  """공인 여부"""
  isCertified: Boolean!
}

"""페르소나 직업"""
enum Job {
  STUDENT
  EDUCATOR
  JOB_SEEKER
  EMPLOYEE
  IT
  FINANCE
  ART
  ETC
}

"""직업 검색 인터페이스"""
input JobFilter {
  """검색할 직업"""
  job: Job!
}

"""Input data for `joinChallenge` mutation"""
input JoinChallengeInput {
  challengeId: GlobalID!
  personaId: GlobalID!
}

union JoinChallengePayload = Challenge | OperationInfo

"""멤버쉽 가입 input"""
input JoinMembershipInput {
  """구독 대상 페르소나"""
  creator: NodeInput!

  """티어"""
  tier: Tier!
}

"""
The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).
"""
scalar JSON

"""멤버쉽 가입 input"""
input LeaveMembershipInput {
  """구독 대상 페르소나"""
  creator: NodeInput!
}

union LoginResult = User | AnonymousOnlyError | WrongCertInfoError

"""
구독자-창작자 멤버쉽
- 구독자 : 멤버쉽 = 1 : N
- 창작자 : 멤버쉽 = 1 : N
"""
type Membership implements Node {
  id: GlobalID!

  """구독자 페르소나"""
  subscriber: Persona!

  """창작자 페르소나"""
  creator: Persona!

  """티어"""
  tier: Tier!

  """생성 일시"""
  createdAt: DateTime!
}

"""A connection to a list of items."""
type MembershipConnection {
  """Pagination data for this connection"""
  pageInfo: PageInfo!

  """Contains the nodes in this connection"""
  edges: [MembershipEdge!]!

  """Total quantity of existing nodes"""
  totalCount: Int
}

"""An edge in a connection."""
type MembershipEdge {
  """A cursor for use in pagination"""
  cursor: String!

  """The item at the end of the edge"""
  node: Membership!
}

union MembershipJoinResult = Membership | AuthInfoRequiredError | PersonaContextRequiredError | AlreadyJoinedMembershipError

"""멤버쉽 정렬 기준"""
enum MembershipSortBy {
  """ID"""
  ID

  """생성 일시"""
  CREATED_AT

  """구독자 닉네임"""
  SUBSCRIBER_NICKNAME

  """창작자 닉네임"""
  CREATOR_NICKNAME

  """티어"""
  TIER
}

"""멤버쉽 목록 조회시 적용할 정렬 방법"""
input MembershipSortingOption {
  """정렬 기준"""
  sortBy: MembershipSortBy = ID

  """정렬 방향"""
  direction: SortingDirection = ASC
}

type Mutation {
  """
  username, email, password로 회원 가입을 시도한다.
  단, username, email은 각각 Unique하다.
  """
  register(username: String!, email: String!, password: String!): RegisterOrLoginResult!

  """username과 password로 로그인을 시도한다."""
  login(username: String!, password: String!): LoginResult!

  """로그아웃을 수행한다."""
  logout: Void

  """새 게시물을 생성한다."""
  postCreate(newPostInput: CreatePostInput!): CreatePostResult!

    """게시물을 삭제한다."""
  deletePost(postId: GlobalID!): Void

  """
  특정 게시물에 대한 좋아요 토글을 수행한다.
  수행 결과 좋아요 상태가 되었다면 True, 그렇지 않다면 False를 반환한다.
  """
  postLikeToggle(postId: GlobalID!): Boolean!

  """
  특정 게시물에 대한 북마크를 수행한다.
  :return: 수행 결과 북마크 된 상태인 경우 True, 그렇지 않은 경우 False
  """
  postBookmarkToggle(postId: GlobalID!): Boolean!

  """
  특정 게시물에 댓글을 작성한다.
  :return: 생성된 댓글
  """
  writeComment(postId: GlobalID!, body: String!): Comment!

  """새 Persona를 생성한다."""
  personaCreate(newPersonaInput: PersonaCreateInput!): CreatePersonaResult!

  """특정 페르소나에 대한 팔로우/언팔로우 토글을 수행한다."""
  personaFollowToggle(personaFollowInput: PersonaFollowToggleInput!): PersonaFollowToggleResult!

  """
  새 태그를 생성한다.
  단, 중복되는 태그 이름이 있는 경우 기존의 태그를 반환한다.
  """
  tagInsert(body: String!): UpsertTagResult!

  """새 카테고리를 생성한다."""
  categoryCreate(body: String!): CreateCategoryResult!

  """특정 페르소나의 멤버쉽에 가입을 요청한다."""
  joinMembership(joinInput: JoinMembershipInput!): MembershipJoinResult!

  """특정 페르소나의 멤버쉽에서 탈퇴한다."""
  leaveMembership(leaveInput: LeaveMembershipInput!): PersonaContextRequiredError
  createChallenge(input: CreateChallengeInput!): Challenge!
  createChallengeObjective(input: CreateChallengeObjectiveInput!): ChallengeObjective!
  toggleChallengeObjective(challengeObjectiveId: GlobalID!, personaId: GlobalID!): ChallengeObjectiveHistory!
  joinChallenge(
    """Input data for `joinChallenge` mutation"""
    input: JoinChallengeInput!
  ): JoinChallengePayload!
}

"""닉네임 검색 인터페이스"""
input NicknameFilter {
  """검색 모드"""
  mode: StringFindMode = EXACTLY

  """검색 문자열"""
  token: String!
}

"""An object with a Globally Unique ID"""
interface Node {
  """The Globally Unique ID of this object"""
  id: GlobalID!
}

"""Input of an object that implements the `Node` interface."""
input NodeInput {
  id: GlobalID!
}

"""Multiple messages returned by an operation."""
type OperationInfo {
  """List of messages returned by the operation."""
  messages: [OperationMessage!]!
}

"""An error that happened while executing an operation."""
type OperationMessage {
  """The kind of this message."""
  kind: OperationMessageKind!

  """The error message."""
  message: String!

  """
  The field that caused the error, or `null` if it isn't associated with any particular field.
  """
  field: String
}

"""The kind of the returned message."""
enum OperationMessageKind {
  INFO
  WARNING
  ERROR
  PERMISSION
  VALIDATION
}

"""Information to aid in pagination."""
type PageInfo {
  """When paginating forwards, are there more items?"""
  hasNextPage: Boolean!

  """When paginating backwards, are there more items?"""
  hasPreviousPage: Boolean!

  """When paginating backwards, the cursor to continue."""
  startCursor: String

  """When paginating forwards, the cursor to continue."""
  endCursor: String
}

enum ParticipateKind {
  INDIVIDUAL
  GROUP
}

"""요청된 작업에 대한 권한이 없을 경우 발생하는 에러"""
type PermissionDeniedError {
  """요구 권한"""
  requiredPermission: String!
}

"""
구독자, 구독 대상, 컨텐츠 작성자에 해당되는 페르소나
User : Persona = 1 : N
"""
type Persona implements Node {
  id: GlobalID!

  """소유자"""
  owner: User!

  """닉네임 (unique)"""
  nickname: String!

  """소개"""
  introduction: String!

  """공개 여부"""
  isPublic: Boolean!

  """성별"""
  gender: Gender

  """생년"""
  birthYear: Int

  """직업"""
  job: String

  """공식 인증 여부"""
  isCertified: Boolean!
  preferredTags(
    """Returns the items in the list that come before the specified cursor."""
    before: String = null

    """Returns the items in the list that come after the specified cursor."""
    after: String = null

    """Returns the first n items from the list."""
    first: Int = null

    """Returns the items in the list that come after the specified cursor."""
    last: Int = null
  ): TagConnection!
  preferredCategories(
    """Returns the items in the list that come before the specified cursor."""
    before: String = null

    """Returns the items in the list that come after the specified cursor."""
    after: String = null

    """Returns the first n items from the list."""
    first: Int = null

    """Returns the items in the list that come after the specified cursor."""
    last: Int = null
  ): CategoryConnection!
  followingPersonas(
    """Returns the items in the list that come before the specified cursor."""
    before: String = null

    """Returns the items in the list that come after the specified cursor."""
    after: String = null

    """Returns the first n items from the list."""
    first: Int = null

    """Returns the items in the list that come after the specified cursor."""
    last: Int = null
  ): PersonaConnection!
  followerPersonas(
    """Returns the items in the list that come before the specified cursor."""
    before: String = null

    """Returns the items in the list that come after the specified cursor."""
    after: String = null

    """Returns the first n items from the list."""
    first: Int = null

    """Returns the items in the list that come after the specified cursor."""
    last: Int = null
  ): PersonaConnection!

  """생성 일시"""
  createdAt: DateTime!

  """갱신 일시"""
  updatedAt: DateTime!

  """북마크 목록"""
  bookmarks: [Bookmark!]!

  """좋아요 한 포스트 목록"""
  likedPosts: [Post!]!
}

"""A connection to a list of items."""
type PersonaConnection {
  """Pagination data for this connection"""
  pageInfo: PageInfo!

  """Contains the nodes in this connection"""
  edges: [PersonaEdge!]!

  """Total quantity of existing nodes"""
  totalCount: Int
}

"""Header 또는 Cookie를 통해 필요한 context를 얻을 수 없는 경우 발생"""
type PersonaContextRequiredError {
  message: String!

  """요구되는 Header/Cookie의 key value"""
  requriedKey: String!
}

"""페르소나 생성에 필요한 정보"""
input PersonaCreateInput {
  """닉네임 (unique)"""
  nickname: String!

  """소개"""
  introduction: String = "자기소개가 없습니다."

  """공개 여부"""
  isPublic: Boolean = true

  """성별"""
  gender: Gender = null

  """나이"""
  birthYear: Int = null

  """직업"""
  job: Job = null

  """선호하는 태그의 body 목록 (insert 됨)"""
  preferredTagBodies: [String!] = []

  """선호 카테고리 목록"""
  preferredCategories: [CategoryIDInput!] = []
}

"""An edge in a connection."""
type PersonaEdge {
  """A cursor for use in pagination"""
  cursor: String!

  """The item at the end of the edge"""
  node: Persona!
}

"""페르소나 팔로우/언팔로우 토글에 필요한 정보"""
input PersonaFollowToggleInput {
  """팔로우/언팔로우의 대상이 되는 페르소나의 ID"""
  followeePersona: GlobalID!
}

"""페르소나 팔로우/언팔로우 토글 결과"""
type PersonaFollowToggleOutput {
  """팔로우/언팔로우 토글을 수행한 페르소나의 ID"""
  followeePersona: GlobalID!

  """작업 수행 후 팔로우 여부"""
  followed: Boolean!
}

union PersonaFollowToggleResult = PersonaFollowToggleOutput | AuthInfoRequiredError | PermissionDeniedError | SelfFollowError

"""이미 사용중인 nickname으로 페르소나 생성/갱신을 시도한 경우 발생"""
type PersonaNicknameDuplicatedError {
  """중복 필드 이름"""
  violatedFieldName: String!

  """중복된 페르소나 닉네임 값"""
  violatedFieldValue: String!
  message: String!
}

"""페르소나 정렬 기준"""
enum PersonaSortBy {
  """ID"""
  ID

  """닉네임"""
  NICKNAME

  """생성 일시"""
  CREATED_AT

  """게시물 총 조회수"""
  TOTAL_POST_READ_CNT

  """팔로워 수"""
  FOLLOWER_CNT
}

"""페르소나 목록 조회 시 적용할 정렬 방법"""
input PersonaSortingOption {
  """정렬 기준"""
  sortBy: PersonaSortBy = CREATED_AT

  """정렬 방향"""
  direction: SortingDirection = DESC
}

"""게시물 관련 통계 데이터 묶음"""
type PersonaStatistics {
  """태그 점수"""
  tagScores: [FieldScore!]!

  """카테고리 점수"""
  categoryScores: [FieldScore!]!

  """성별 점수"""
  genderScores: [FieldScore!]!

  """생년 점수"""
  birthYearScores: [FieldScore!]!

  """직업 점수"""
  jobScores: [FieldScore!]!
}

type Post implements Node {
  id: GlobalID!

  """글 제목"""
  title: String!

  """글 내용"""
  content: String!

  """글 내용 미리보기"""
  contentPreview: String

  """유료 내용"""
  paidContent: String

  """작성자"""
  author: Persona!

  """공개 여부"""
  isPublic: Boolean!
  tags(
    """Returns the items in the list that come before the specified cursor."""
    before: String = null

    """Returns the items in the list that come after the specified cursor."""
    after: String = null

    """Returns the first n items from the list."""
    first: Int = null

    """Returns the items in the list that come after the specified cursor."""
    last: Int = null
  ): TagConnection!

  """소속 카테고리"""
  category: Category

  """조회 요구 티어"""
  requiredMembershipTier: Tier

  """좋아요 개수"""
  likeCnt: Int!

  """댓글 목록"""
  comments: [Comment!]!

  """댓글 갯수"""
  commentCnt: Int!

  """북마크 개수"""
  bookmarkCnt: Int!

  """생성 시각"""
  createdAt: DateTime!

  """갱신 시각"""
  updatedAt: DateTime!
}

"""A connection to a list of items."""
type PostConnection {
  """Pagination data for this connection"""
  pageInfo: PageInfo!

  """Contains the nodes in this connection"""
  edges: [PostEdge!]!

  """Total quantity of existing nodes"""
  totalCount: Int
}

"""An edge in a connection."""
type PostEdge {
  """A cursor for use in pagination"""
  cursor: String!

  """The item at the end of the edge"""
  node: Post!
}

"""특정 게시물에 대한 독자 페르소나의 주요 특징을 반환 받기 위한 입력"""
input PostReaderPersonaStatisticsInput {
  """대상 게시물의 ID"""
  postId: GlobalID!

  """재방문 횟수 하한"""
  minRevisit: Int! = 1

  """응답될 항목의 최대 개수"""
  resultLimit: Int = 100
}

"""게시물 정렬 기준"""
enum PostSortBy {
  """ID"""
  ID

  """생성 일시"""
  CREATED_AT

  """조회수"""
  READ_CNT
}

"""게시물 목록 조회시 적용할 정렬 방법"""
input PostSortingOption {
  """정렬 기준"""
  sortBy: PostSortBy = CREATED_AT

  """정렬 방향"""
  direction: SortingDirection = DESC
}

"""게시물 관련 통계 데이터 묶음"""
type PostStatistics {
  """태그 점수"""
  tagScores: [FieldScore!]!

  """카테고리 점수"""
  categoryScores: [FieldScore!]!

  """작성자 페르소나의 주요 특징"""
  authorScores: PersonaStatistics!
}

type Query {
  """공개된 모든 게시물의 목록"""
  getPublicPosts(
    """Returns the items in the list that come before the specified cursor."""
    before: String = null

    """Returns the items in the list that come after the specified cursor."""
    after: String = null

    """Returns the first n items from the list."""
    first: Int = null

    """Returns the items in the list that come after the specified cursor."""
    last: Int = null
    sortingOpt: PostSortingOption!
    createdAtFilter: DatetimeBetween = null
    authorFilter: AuthorFilter = null
    titleFilter: TitleFilter = null
    categoryFilter: CategoryFilter = null
    tagsFilter: TagFilter = null
  ): PostConnection!

  """게시물 한 건 조회"""
  getPost(postId: GlobalID!): Post!

  """시스템에 등록된 모든 게시물의 목록"""
  getEntirePosts(
    """Returns the items in the list that come before the specified cursor."""
    before: String = null

    """Returns the items in the list that come after the specified cursor."""
    after: String = null

    """Returns the first n items from the list."""
    first: Int = null

    """Returns the items in the list that come after the specified cursor."""
    last: Int = null
    sortingOpt: PostSortingOption!
    createdAtFilter: DatetimeBetween = null
    authorFilter: AuthorFilter = null
    titleFilter: TitleFilter = null
    categoryFilter: CategoryFilter = null
    tagsFilter: TagFilter = null
  ): PostConnection!
  getImageUploadUrl(imageName: String!): ImageUploadUrl!

  """로그인한 사용자의 페르소나 목록"""
  getOwnPersonas(
    """Returns the items in the list that come before the specified cursor."""
    before: String = null

    """Returns the items in the list that come after the specified cursor."""
    after: String = null

    """Returns the first n items from the list."""
    first: Int = null

    """Returns the items in the list that come after the specified cursor."""
    last: Int = null
    sortingOpt: PersonaSortingOption!
    createdAtFilter: DatetimeBetween = null
    birthYearFilter: BirthYearFilter = null
    nicknameFilter: NicknameFilter = null
    genderFilter: GenderFilter = null
    isCertifiedFilter: IsCertifiedFilter = null
    jobFilter: JobFilter = null
  ): PersonaConnection!

  """모든 공개 페르소나의 목록"""
  getPublicPersonas(
    """Returns the items in the list that come before the specified cursor."""
    before: String = null

    """Returns the items in the list that come after the specified cursor."""
    after: String = null

    """Returns the first n items from the list."""
    first: Int = null

    """Returns the items in the list that come after the specified cursor."""
    last: Int = null
    sortingOpt: PersonaSortingOption!
    createdAtFilter: DatetimeBetween = null
    birthYearFilter: BirthYearFilter = null
    nicknameFilter: NicknameFilter = null
    genderFilter: GenderFilter = null
    isCertifiedFilter: IsCertifiedFilter = null
    jobFilter: JobFilter = null
  ): PersonaConnection!

  """페르소나 한 건 조회 (Public한 정보만 노출)"""
  getPublicPersona(personaId: GlobalID!): Persona!

  """
  새 태그를 생성한다.
  단, 중복되는 태그 이름이 있는 경우 기존의 태그를 반환한다.
  """
  tagInsert(body: String!): UpsertTagResult!
  tag(
    """The ID of the object."""
    id: GlobalID!
  ): Tag

  """등록된 모든 태그의 목록"""
  getAllTags(
    """Returns the items in the list that come before the specified cursor."""
    before: String = null

    """Returns the items in the list that come after the specified cursor."""
    after: String = null

    """Returns the first n items from the list."""
    first: Int = null

    """Returns the items in the list that come after the specified cursor."""
    last: Int = null
    sortingOpt: TagSortingOption!
    createdAtFilter: DatetimeBetween = null
    bodyFilter: TagBodyFilter = null
  ): TagConnection!

  """시스템에 등록된 모든 카테고리의 목록을 반환"""
  getAllCategories(
    """Returns the items in the list that come before the specified cursor."""
    before: String = null

    """Returns the items in the list that come after the specified cursor."""
    after: String = null

    """Returns the first n items from the list."""
    first: Int = null

    """Returns the items in the list that come after the specified cursor."""
    last: Int = null
    sortingOpt: CategorySortingOption!
    createdAtFilter: DatetimeBetween = null
    bodyFilter: CategoryBodyFilter = null
  ): CategoryConnection!

  """요청한 페르소나의 멤버쉽 목록"""
  getOwnMemberships(
    """Returns the items in the list that come before the specified cursor."""
    before: String = null

    """Returns the items in the list that come after the specified cursor."""
    after: String = null

    """Returns the first n items from the list."""
    first: Int = null

    """Returns the items in the list that come after the specified cursor."""
    last: Int = null
    mode: GetMembershipAs!
    sortingOpt: MembershipSortingOption!
  ): MembershipConnection!

  """사용자가 읽은 게시물에 대한 통계 정보를 반환한다."""
  getOwnReadPostStatistics(opt: GetOwnReadPostStatisticsInput!): PostStatistics!

  """요청한 페르소나가 팔로우 하고 있는 페르소나의 주요 특징을 반환한다."""
  getFollowingPersonasStatistics(opt: GetFollowingPersonaStatisticsInput!): PersonaStatistics!

  """특정 페르소나의 팔로워 페르소나의 주요 특징을 반환한다."""
  getPersonaFollowersStatistics(opt: GetPersonaFollowerStatisticsInput!): PersonaStatistics!

  """특정 게시물에 대한 독자 페르소나의 주요 특징을 반환한다."""
  getPostReaderStatistics(opt: PostReaderPersonaStatisticsInput!): PersonaStatistics!

  """사용자의 일별 읽은 게시물의 수를 반환한다."""
  getOwnReadPostStatisticsPerDay(between: StatisticsDatetimeBetween!): CountStatistics!

  """사용자의 시간대별 읽은 게시물의 갯수를 반환한다."""
  getOwnReadPostStatisticsPerHour(between: StatisticsDatetimeBetween!): CountStatistics!

  """사용자의 요일별 읽은 게시물의 갯수를 반환한다."""
  getOwnReadPostStatisticsPerWeekday(between: StatisticsDatetimeBetween!): CountStatistics!

  """사용자가 일정 기간 동안 읽은 게시물들의 포스트를 기준으로 갯수를 반환한다."""
  getOwnReadPostStatisticsPerAuthor(between: StatisticsDatetimeBetween!): CountStatistics!
  getAllChallenges(
    """Returns the items in the list that come before the specified cursor."""
    before: String = null

    """Returns the items in the list that come after the specified cursor."""
    after: String = null

    """Returns the first n items from the list."""
    first: Int = null

    """Returns the items in the list that come after the specified cursor."""
    last: Int = null
  ): ChallengeConnection!
  getMyChallenges(
    """Returns the items in the list that come before the specified cursor."""
    before: String = null

    """Returns the items in the list that come after the specified cursor."""
    after: String = null

    """Returns the first n items from the list."""
    first: Int = null

    """Returns the items in the list that come after the specified cursor."""
    last: Int = null
    personaId: GlobalID!
  ): ChallengeConnection!
  getMyChallengeObjectives(
    """Returns the items in the list that come before the specified cursor."""
    before: String = null

    """Returns the items in the list that come after the specified cursor."""
    after: String = null

    """Returns the first n items from the list."""
    first: Int = null

    """Returns the items in the list that come after the specified cursor."""
    last: Int = null
    personaId: GlobalID!
    challengeId: GlobalID!
  ): ChallengeObjectiveConnection!
}

union RegisterOrLoginResult = User | AnonymousOnlyError | UsernameAlreadyUsedError | EmailAlreadyUsedError

"""요청된 자원을 검색하는데 실패한 경우 발생하는 에러"""
type ResourceNotFoundError {
  """요청한 자원의 종류"""
  resourceName: String!
}

"""스스로에 대한 follow를 수행하려 했을 때 발생하는 에러"""
type SelfFollowError {
  message: String!
}

"""정렬 오름차순/내림차순"""
enum SortingDirection {
  ASC
  DESC
}

"""통계에 사용할 데이터의 날짜 범위"""
input StatisticsDatetimeBetween {
  """조회 시작 일시 (기본값 : 30일 이전)"""
  startDatetime: DateTime = "2023-04-18T20:28:49.266423"

  """조회 종료 일시 (기본값 : 오늘)"""
  endDatetime: DateTime = "2023-05-18T20:28:49.266442"
}

enum StringFindMode {
  EXACTLY
  CONTAINS
  STARTS_WITH
  ENDS_WITH
}

"""
Post를 설명하거나, Persona의 선호 대상이 되는 태그
- Post : Tag = N : M
- Persona : Tag = N : M
"""
type Tag implements Node {
  id: GlobalID!

  """태그 본문"""
  body: String!

  """생성 일시"""
  createdAt: DateTime!
}

"""태그 검색 인터페이스"""
input TagBodyFilter {
  """검색 모드"""
  mode: StringFindMode = EXACTLY

  """검색 문자열"""
  token: String!
}

"""태그 body의 길이가 기준치보다 긴 경우 발생"""
type TagBodyTooLongError {
  """위반 필드 값"""
  violatedFieldName: String!

  """위반 사유 상세"""
  detail: String
  message: String!

  """전달된 태그 body 값"""
  violatedFieldValue: String!
}

"""태그 body의 길이가 기준치보다 짧은 경우 발생"""
type TagBodyTooShortError {
  """위반 필드 값"""
  violatedFieldName: String!

  """위반 사유 상세"""
  detail: String
  message: String!

  """전달된 태그 body 값"""
  violatedFieldValue: String!
}

"""A connection to a list of items."""
type TagConnection {
  """Pagination data for this connection"""
  pageInfo: PageInfo!

  """Contains the nodes in this connection"""
  edges: [TagEdge!]!

  """Total quantity of existing nodes"""
  totalCount: Int
}

"""An edge in a connection."""
type TagEdge {
  """A cursor for use in pagination"""
  cursor: String!

  """The item at the end of the edge"""
  node: Tag!
}

"""태그 검색 인터페이스 (or 적용)"""
input TagFilter {
  """태그 ID 목록"""
  tagIds: [GlobalID!]!
}

"""Tag insertion 결과"""
type TagInsertionResult {
  """Upsert된 태그"""
  tag: Tag!

  """새로 생성된 경우 true, 아닌 경우 false"""
  isCreated: Boolean!
}

"""태그 정렬 기준"""
enum TagSortBy {
  """ID"""
  ID

  """사전순"""
  LEXICOGRAPHICAL

  """생성 일시"""
  CREATED_AT

  """선호 페르소나 수 기준"""
  PERSONA_PREFERENCE_CNT

  """연결된 게시물 수 기준"""
  POST_CONNECTION_CNT
}

"""태그 목록 조회 시 적용할 정렬 방법"""
input TagSortingOption {
  """정렬 기준"""
  sortBy: TagSortBy = ID

  """정렬 방향"""
  direction: SortingDirection = ASC
}

"""멤버쉽 티어"""
enum Tier {
  TIER_1
  TIER_2
  TIER_3
  TIER_4
  TIER_5
  TIER_6
}

"""제목 검색 인터페이스"""
input TitleFilter {
  """검색 모드"""
  mode: StringFindMode = EXACTLY

  """검색 문자열"""
  token: String!
}

union UpsertTagResult = TagInsertionResult | AuthInfoRequiredError | TagBodyTooShortError | TagBodyTooLongError

type User implements Node {
  id: GlobalID!

  """사용자 ID (Unique)"""
  username: String!

  """사용자 E-mail (Unique)"""
  email: String!

  """로그인 방법"""
  signupMethod: GraphqlAppUserSignupMethodEnum!

  """생성 시각"""
  createdAt: DateTime!

  """갱신 시각"""
  updatedAt: DateTime!
}

"""이미 사용 중인 username으로 User에 대한 생성/수정을 시도하려는 경우"""
type UsernameAlreadyUsedError {
  violatedFieldName: String!

  """중복된 username 값"""
  violatedFieldValue: String!
  message: String!
}

"""Represents NULL values"""
scalar Void

"""잘못된 인증 정보(email, password 등)이 전달 되어 로그인에 실패한 경우"""
type WrongCertInfoError {
  message: String!
}