Merge pull request 'Notifications Operation' (#206) from loewy/notifications-operations into master

Reviewed-on: #206

src/index.tsx

@@ -2286,6 +2286,7 @@ export type Mutation = {
   createSubscription: CreateSubscriptionResultGql;
   createUploadStream: CreateUploadStreamReturn;
   deleteComment: Scalars["Boolean"]["output"];
+  deleteNotification: Scalars["Boolean"]["output"];
   deleteTags: Scalars["Boolean"]["output"];
   deleteUser: Scalars["Boolean"]["output"];
   deleteVideo: Scalars["Boolean"]["output"];
@@ -2300,6 +2301,9 @@ export type Mutation = {
   getHlsInitUploadLink: GetUploadLinkReturn;
   getProfileImageUploadLink: GetProfileUploadLinkReturn;
   getUploadLink: GetUploadLinkReturn;
+  markAllNotificationsAsRead: Scalars["Boolean"]["output"];
+  markNotificationAsRead: Scalars["Boolean"]["output"];
+  markNotificationsAsRead: Scalars["Boolean"]["output"];
   reactToVideo: Scalars["Boolean"]["output"];
   reportContent: Scalars["Boolean"]["output"];
   retireTags: Scalars["Boolean"]["output"];
@@ -2346,6 +2350,10 @@ export type MutationDeleteCommentArgs = {
   videoId: Scalars["Int"]["input"];
 };
 
+export type MutationDeleteNotificationArgs = {
+  notificationId: Scalars["Int"]["input"];
+};
+
 export type MutationDeleteTagsArgs = {
   tagsToDelete: Array<VideoTagInput>;
   videoId: Scalars["Int"]["input"];
@@ -2401,6 +2409,14 @@ export type MutationGetUploadLinkArgs = {
   videoId: Scalars["Int"]["input"];
 };
 
+export type MutationMarkNotificationAsReadArgs = {
+  notificationId: Scalars["Int"]["input"];
+};
+
+export type MutationMarkNotificationsAsReadArgs = {
+  notificationIds: Array<Scalars["Int"]["input"]>;
+};
+
 export type MutationReactToVideoArgs = {
   reaction?: InputMaybe<ReactionEnum>;
   videoId: Scalars["Int"]["input"];
@@ -2441,6 +2457,39 @@ export type NoInitForChunkedUploadErr = {
   segmentType: StreamSegmentTypeEnum;
 };
 
+export type NotificationConnection = {
+  __typename?: "NotificationConnection";
+  hasMore: Scalars["Boolean"]["output"];
+  notifications: Array<NotificationGql>;
+  totalCount: Scalars["Int"]["output"];
+  unreadCount: Scalars["Int"]["output"];
+};
+
+export type NotificationFilters = {
+  isRead?: InputMaybe<Scalars["Boolean"]["input"]>;
+  notificationTypes?: InputMaybe<Array<NotificationTypeEnum>>;
+};
+
+export type NotificationGql = {
+  __typename?: "NotificationGQL";
+  actor: UserGql;
+  comment?: Maybe<CommentGql>;
+  createdAt: Scalars["DateTime"]["output"];
+  id: Scalars["Int"]["output"];
+  isRead: Scalars["Boolean"]["output"];
+  notificationType: NotificationTypeEnum;
+  reactionType?: Maybe<Scalars["String"]["output"]>;
+  readAt?: Maybe<Scalars["DateTime"]["output"]>;
+  videoId?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export enum NotificationTypeEnum {
+  Comment = "COMMENT",
+  CommentReply = "COMMENT_REPLY",
+  Follow = "FOLLOW",
+  Reaction = "REACTION",
+}
+
 export type OtherErrorNeedsNote = {
   __typename?: "OtherErrorNeedsNote";
   msg?: Maybe<Scalars["String"]["output"]>;
@@ -2550,6 +2599,8 @@ export type Query = {
   getVideo: VideoGql;
   getVideoMakePercentageIntervals: Array<MakePercentageIntervalGql>;
   getVideos: Array<VideoGql>;
+  notifications: NotificationConnection;
+  unreadNotificationCount: Scalars["Int"]["output"];
   waitFor: Scalars["Float"]["output"];
 };
 
@@ -2689,6 +2740,12 @@ export type QueryGetVideosArgs = {
   videoIds: Array<Scalars["Int"]["input"]>;
 };
 
+export type QueryNotificationsArgs = {
+  filters?: InputMaybe<NotificationFilters>;
+  limit?: Scalars["Int"]["input"];
+  offset?: Scalars["Int"]["input"];
+};
+
 export type QueryWaitForArgs = {
   duration: Scalars["Float"]["input"];
 };
@@ -3956,6 +4013,122 @@ export type GetMedalsQuery = {
   };
 };
 
+export type GetNotificationsQueryVariables = Exact<{
+  limit?: Scalars["Int"]["input"];
+  offset?: Scalars["Int"]["input"];
+  filters?: InputMaybe<NotificationFilters>;
+}>;
+
+export type GetNotificationsQuery = {
+  __typename?: "Query";
+  notifications: {
+    __typename?: "NotificationConnection";
+    totalCount: number;
+    unreadCount: number;
+    hasMore: boolean;
+    notifications: Array<{
+      __typename?: "NotificationGQL";
+      id: number;
+      notificationType: NotificationTypeEnum;
+      videoId?: number | null;
+      reactionType?: string | null;
+      isRead: boolean;
+      createdAt: any;
+      readAt?: any | null;
+      actor: {
+        __typename?: "UserGQL";
+        id: number;
+        username: string;
+        profileImageUri?: string | null;
+      };
+      comment?: {
+        __typename?: "CommentGQL";
+        id: number;
+        message: string;
+        user: {
+          __typename?: "UserGQL";
+          id: number;
+          username: string;
+          profileImageUri?: string | null;
+        };
+      } | null;
+    }>;
+  };
+};
+
+export type GetUnreadNotificationCountQueryVariables = Exact<{
+  [key: string]: never;
+}>;
+
+export type GetUnreadNotificationCountQuery = {
+  __typename?: "Query";
+  unreadNotificationCount: number;
+};
+
+export type MarkNotificationAsReadMutationVariables = Exact<{
+  notificationId: Scalars["Int"]["input"];
+}>;
+
+export type MarkNotificationAsReadMutation = {
+  __typename?: "Mutation";
+  markNotificationAsRead: boolean;
+};
+
+export type MarkNotificationsAsReadMutationVariables = Exact<{
+  notificationIds: Array<Scalars["Int"]["input"]> | Scalars["Int"]["input"];
+}>;
+
+export type MarkNotificationsAsReadMutation = {
+  __typename?: "Mutation";
+  markNotificationsAsRead: boolean;
+};
+
+export type MarkAllNotificationsAsReadMutationVariables = Exact<{
+  [key: string]: never;
+}>;
+
+export type MarkAllNotificationsAsReadMutation = {
+  __typename?: "Mutation";
+  markAllNotificationsAsRead: boolean;
+};
+
+export type DeleteNotificationMutationVariables = Exact<{
+  notificationId: Scalars["Int"]["input"];
+}>;
+
+export type DeleteNotificationMutation = {
+  __typename?: "Mutation";
+  deleteNotification: boolean;
+};
+
+export type NotificationFragment = {
+  __typename?: "NotificationGQL";
+  id: number;
+  notificationType: NotificationTypeEnum;
+  videoId?: number | null;
+  reactionType?: string | null;
+  isRead: boolean;
+  createdAt: any;
+  readAt?: any | null;
+  actor: {
+    __typename?: "UserGQL";
+    id: number;
+    username: string;
+    profileImageUri?: string | null;
+  };
+  comment?: {
+    __typename?: "CommentGQL";
+    id: number;
+    message: string;
+    user: {
+      __typename?: "UserGQL";
+      id: number;
+      username: string;
+      profileImageUri?: string | null;
+    };
+  } | null;
+};
+
 export type EnsureStripeCustomerExistsMutationVariables = Exact<{
   [key: string]: never;
 }>;
@@ -5041,6 +5214,9 @@ export type GetVideoSocialDetailsByIdQuery = {
     __typename?: "VideoGQL";
     id: number;
     name?: string | null;
+    screenshotUri?: string | null;
+    makePercentage: number;
+    totalShots: number;
     owner?: {
       __typename?: "UserGQL";
       id: number;
@@ -5770,6 +5946,31 @@ export const MedalFieldsFragmentDoc = gql`
     nickname
   }
 `;
+export const NotificationFragmentDoc = gql`
+  fragment Notification on NotificationGQL {
+    id
+    notificationType
+    actor {
+      id
+      username
+      profileImageUri
+    }
+    videoId
+    comment {
+      id
+      message
+      user {
+        id
+        username
+        profileImageUri
+      }
+    }
+    reactionType
+    isRead
+    createdAt
+    readAt
+  }
+`;
 export const PocketingIntentionFragmentFragmentDoc = gql`
   fragment PocketingIntentionFragment on PocketingIntentionFeaturesGQL {
     make
@@ -7029,6 +7230,353 @@ export type GetMedalsQueryResult = Apollo.QueryResult<
   GetMedalsQuery,
   GetMedalsQueryVariables
 >;
+export const GetNotificationsDocument = gql`
+  query GetNotifications(
+    $limit: Int! = 20
+    $offset: Int! = 0
+    $filters: NotificationFilters = null
+  ) {
+    notifications(limit: $limit, offset: $offset, filters: $filters) {
+      notifications {
+        ...Notification
+      }
+      totalCount
+      unreadCount
+      hasMore
+    }
+  }
+  ${NotificationFragmentDoc}
+`;
+
+/**
+ * __useGetNotificationsQuery__
+ *
+ * To run a query within a React component, call `useGetNotificationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetNotificationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetNotificationsQuery({
+ *   variables: {
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *      filters: // value for 'filters'
+ *   },
+ * });
+ */
+export function useGetNotificationsQuery(
+  baseOptions?: Apollo.QueryHookOptions<
+    GetNotificationsQuery,
+    GetNotificationsQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<GetNotificationsQuery, GetNotificationsQueryVariables>(
+    GetNotificationsDocument,
+    options,
+  );
+}
+export function useGetNotificationsLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    GetNotificationsQuery,
+    GetNotificationsQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<
+    GetNotificationsQuery,
+    GetNotificationsQueryVariables
+  >(GetNotificationsDocument, options);
+}
+export function useGetNotificationsSuspenseQuery(
+  baseOptions?: Apollo.SuspenseQueryHookOptions<
+    GetNotificationsQuery,
+    GetNotificationsQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<
+    GetNotificationsQuery,
+    GetNotificationsQueryVariables
+  >(GetNotificationsDocument, options);
+}
+export type GetNotificationsQueryHookResult = ReturnType<
+  typeof useGetNotificationsQuery
+>;
+export type GetNotificationsLazyQueryHookResult = ReturnType<
+  typeof useGetNotificationsLazyQuery
+>;
+export type GetNotificationsSuspenseQueryHookResult = ReturnType<
+  typeof useGetNotificationsSuspenseQuery
+>;
+export type GetNotificationsQueryResult = Apollo.QueryResult<
+  GetNotificationsQuery,
+  GetNotificationsQueryVariables
+>;
+export const GetUnreadNotificationCountDocument = gql`
+  query GetUnreadNotificationCount {
+    unreadNotificationCount
+  }
+`;
+
+/**
+ * __useGetUnreadNotificationCountQuery__
+ *
+ * To run a query within a React component, call `useGetUnreadNotificationCountQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetUnreadNotificationCountQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetUnreadNotificationCountQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useGetUnreadNotificationCountQuery(
+  baseOptions?: Apollo.QueryHookOptions<
+    GetUnreadNotificationCountQuery,
+    GetUnreadNotificationCountQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<
+    GetUnreadNotificationCountQuery,
+    GetUnreadNotificationCountQueryVariables
+  >(GetUnreadNotificationCountDocument, options);
+}
+export function useGetUnreadNotificationCountLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    GetUnreadNotificationCountQuery,
+    GetUnreadNotificationCountQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<
+    GetUnreadNotificationCountQuery,
+    GetUnreadNotificationCountQueryVariables
+  >(GetUnreadNotificationCountDocument, options);
+}
+export function useGetUnreadNotificationCountSuspenseQuery(
+  baseOptions?: Apollo.SuspenseQueryHookOptions<
+    GetUnreadNotificationCountQuery,
+    GetUnreadNotificationCountQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<
+    GetUnreadNotificationCountQuery,
+    GetUnreadNotificationCountQueryVariables
+  >(GetUnreadNotificationCountDocument, options);
+}
+export type GetUnreadNotificationCountQueryHookResult = ReturnType<
+  typeof useGetUnreadNotificationCountQuery
+>;
+export type GetUnreadNotificationCountLazyQueryHookResult = ReturnType<
+  typeof useGetUnreadNotificationCountLazyQuery
+>;
+export type GetUnreadNotificationCountSuspenseQueryHookResult = ReturnType<
+  typeof useGetUnreadNotificationCountSuspenseQuery
+>;
+export type GetUnreadNotificationCountQueryResult = Apollo.QueryResult<
+  GetUnreadNotificationCountQuery,
+  GetUnreadNotificationCountQueryVariables
+>;
+export const MarkNotificationAsReadDocument = gql`
+  mutation MarkNotificationAsRead($notificationId: Int!) {
+    markNotificationAsRead(notificationId: $notificationId)
+  }
+`;
+export type MarkNotificationAsReadMutationFn = Apollo.MutationFunction<
+  MarkNotificationAsReadMutation,
+  MarkNotificationAsReadMutationVariables
+>;
+
+/**
+ * __useMarkNotificationAsReadMutation__
+ *
+ * To run a mutation, you first call `useMarkNotificationAsReadMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useMarkNotificationAsReadMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [markNotificationAsReadMutation, { data, loading, error }] = useMarkNotificationAsReadMutation({
+ *   variables: {
+ *      notificationId: // value for 'notificationId'
+ *   },
+ * });
+ */
+export function useMarkNotificationAsReadMutation(
+  baseOptions?: Apollo.MutationHookOptions<
+    MarkNotificationAsReadMutation,
+    MarkNotificationAsReadMutationVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useMutation<
+    MarkNotificationAsReadMutation,
+    MarkNotificationAsReadMutationVariables
+  >(MarkNotificationAsReadDocument, options);
+}
+export type MarkNotificationAsReadMutationHookResult = ReturnType<
+  typeof useMarkNotificationAsReadMutation
+>;
+export type MarkNotificationAsReadMutationResult =
+  Apollo.MutationResult<MarkNotificationAsReadMutation>;
+export type MarkNotificationAsReadMutationOptions = Apollo.BaseMutationOptions<
+  MarkNotificationAsReadMutation,
+  MarkNotificationAsReadMutationVariables
+>;
+export const MarkNotificationsAsReadDocument = gql`
+  mutation MarkNotificationsAsRead($notificationIds: [Int!]!) {
+    markNotificationsAsRead(notificationIds: $notificationIds)
+  }
+`;
+export type MarkNotificationsAsReadMutationFn = Apollo.MutationFunction<
+  MarkNotificationsAsReadMutation,
+  MarkNotificationsAsReadMutationVariables
+>;
+
+/**
+ * __useMarkNotificationsAsReadMutation__
+ *
+ * To run a mutation, you first call `useMarkNotificationsAsReadMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useMarkNotificationsAsReadMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [markNotificationsAsReadMutation, { data, loading, error }] = useMarkNotificationsAsReadMutation({
+ *   variables: {
+ *      notificationIds: // value for 'notificationIds'
+ *   },
+ * });
+ */
+export function useMarkNotificationsAsReadMutation(
+  baseOptions?: Apollo.MutationHookOptions<
+    MarkNotificationsAsReadMutation,
+    MarkNotificationsAsReadMutationVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useMutation<
+    MarkNotificationsAsReadMutation,
+    MarkNotificationsAsReadMutationVariables
+  >(MarkNotificationsAsReadDocument, options);
+}
+export type MarkNotificationsAsReadMutationHookResult = ReturnType<
+  typeof useMarkNotificationsAsReadMutation
+>;
+export type MarkNotificationsAsReadMutationResult =
+  Apollo.MutationResult<MarkNotificationsAsReadMutation>;
+export type MarkNotificationsAsReadMutationOptions = Apollo.BaseMutationOptions<
+  MarkNotificationsAsReadMutation,
+  MarkNotificationsAsReadMutationVariables
+>;
+export const MarkAllNotificationsAsReadDocument = gql`
+  mutation MarkAllNotificationsAsRead {
+    markAllNotificationsAsRead
+  }
+`;
+export type MarkAllNotificationsAsReadMutationFn = Apollo.MutationFunction<
+  MarkAllNotificationsAsReadMutation,
+  MarkAllNotificationsAsReadMutationVariables
+>;
+
+/**
+ * __useMarkAllNotificationsAsReadMutation__
+ *
+ * To run a mutation, you first call `useMarkAllNotificationsAsReadMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useMarkAllNotificationsAsReadMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [markAllNotificationsAsReadMutation, { data, loading, error }] = useMarkAllNotificationsAsReadMutation({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useMarkAllNotificationsAsReadMutation(
+  baseOptions?: Apollo.MutationHookOptions<
+    MarkAllNotificationsAsReadMutation,
+    MarkAllNotificationsAsReadMutationVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useMutation<
+    MarkAllNotificationsAsReadMutation,
+    MarkAllNotificationsAsReadMutationVariables
+  >(MarkAllNotificationsAsReadDocument, options);
+}
+export type MarkAllNotificationsAsReadMutationHookResult = ReturnType<
+  typeof useMarkAllNotificationsAsReadMutation
+>;
+export type MarkAllNotificationsAsReadMutationResult =
+  Apollo.MutationResult<MarkAllNotificationsAsReadMutation>;
+export type MarkAllNotificationsAsReadMutationOptions =
+  Apollo.BaseMutationOptions<
+    MarkAllNotificationsAsReadMutation,
+    MarkAllNotificationsAsReadMutationVariables
+  >;
+export const DeleteNotificationDocument = gql`
+  mutation DeleteNotification($notificationId: Int!) {
+    deleteNotification(notificationId: $notificationId)
+  }
+`;
+export type DeleteNotificationMutationFn = Apollo.MutationFunction<
+  DeleteNotificationMutation,
+  DeleteNotificationMutationVariables
+>;
+
+/**
+ * __useDeleteNotificationMutation__
+ *
+ * To run a mutation, you first call `useDeleteNotificationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteNotificationMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteNotificationMutation, { data, loading, error }] = useDeleteNotificationMutation({
+ *   variables: {
+ *      notificationId: // value for 'notificationId'
+ *   },
+ * });
+ */
+export function useDeleteNotificationMutation(
+  baseOptions?: Apollo.MutationHookOptions<
+    DeleteNotificationMutation,
+    DeleteNotificationMutationVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useMutation<
+    DeleteNotificationMutation,
+    DeleteNotificationMutationVariables
+  >(DeleteNotificationDocument, options);
+}
+export type DeleteNotificationMutationHookResult = ReturnType<
+  typeof useDeleteNotificationMutation
+>;
+export type DeleteNotificationMutationResult =
+  Apollo.MutationResult<DeleteNotificationMutation>;
+export type DeleteNotificationMutationOptions = Apollo.BaseMutationOptions<
+  DeleteNotificationMutation,
+  DeleteNotificationMutationVariables
+>;
 export const EnsureStripeCustomerExistsDocument = gql`
   mutation EnsureStripeCustomerExists {
     ensureStripeCustomerExists {
@@ -9715,6 +10263,9 @@ export const GetVideoSocialDetailsByIdDocument = gql`
     getVideo(videoId: $videoId) {
       id
       name
+      screenshotUri
+      makePercentage
+      totalShots
       owner {
         id
         firebaseUid

src/operations/notifications.gql

@@ -0,0 +1,58 @@
+query GetNotifications(
+  $limit: Int! = 20
+  $offset: Int! = 0
+  $filters: NotificationFilters = null
+) {
+  notifications(limit: $limit, offset: $offset, filters: $filters) {
+    notifications {
+      ...Notification
+    }
+    totalCount
+    unreadCount
+    hasMore
+  }
+}
+
+query GetUnreadNotificationCount {
+  unreadNotificationCount
+}
+
+mutation MarkNotificationAsRead($notificationId: Int!) {
+  markNotificationAsRead(notificationId: $notificationId)
+}
+
+mutation MarkNotificationsAsRead($notificationIds: [Int!]!) {
+  markNotificationsAsRead(notificationIds: $notificationIds)
+}
+
+mutation MarkAllNotificationsAsRead {
+  markAllNotificationsAsRead
+}
+
+mutation DeleteNotification($notificationId: Int!) {
+  deleteNotification(notificationId: $notificationId)
+}
+
+fragment Notification on NotificationGQL {
+  id
+  notificationType
+  actor {
+    id
+    username
+    profileImageUri
+  }
+  videoId
+  comment {
+    id
+    message
+    user {
+      id
+      username
+      profileImageUri
+    }
+  }
+  reactionType
+  isRead
+  createdAt
+  readAt
+}

src/operations/video.gql

@@ -97,6 +97,9 @@ query GetVideoSocialDetailsById($videoId: Int!) {
   getVideo(videoId: $videoId) {
     id
     name
+    screenshotUri
+    makePercentage
+    totalShots
     owner {
       id
       firebaseUid

src/schema.gql

@@ -28,6 +28,12 @@ type Query {
     when: DateTime = null
   ): CountLeaderboardGQL!
   getMedals(scope: MedalScope!, userId: Int = null): RequestedMedalsGQL!
+  notifications(
+    limit: Int! = 20
+    offset: Int! = 0
+    filters: NotificationFilters = null
+  ): NotificationConnection!
+  unreadNotificationCount: Int!
   getRuns(
     filterInput: RunFilterInput!
     runIds: [Int!] = null
@@ -715,6 +721,37 @@ input MedalScope @oneOf {
   datetimeRange: DatetimeRangeAggregationInput
 }
 
+type NotificationConnection {
+  notifications: [NotificationGQL!]!
+  totalCount: Int!
+  unreadCount: Int!
+  hasMore: Boolean!
+}
+
+type NotificationGQL {
+  id: Int!
+  notificationType: NotificationTypeEnum!
+  actor: UserGQL!
+  videoId: Int
+  comment: CommentGQL
+  reactionType: String
+  isRead: Boolean!
+  createdAt: DateTime!
+  readAt: DateTime
+}
+
+enum NotificationTypeEnum {
+  COMMENT
+  COMMENT_REPLY
+  REACTION
+  FOLLOW
+}
+
+input NotificationFilters {
+  isRead: Boolean = null
+  notificationTypes: [NotificationTypeEnum!] = null
+}
+
 type GetRunsResult {
   runs: [RunGQL!]!
   count: Int
@@ -916,6 +953,10 @@ type Mutation {
     reason: ReportReasonEnum!
     customReason: String = null
   ): Boolean!
+  markNotificationAsRead(notificationId: Int!): Boolean!
+  markAllNotificationsAsRead: Boolean!
+  markNotificationsAsRead(notificationIds: [Int!]!): Boolean!
+  deleteNotification(notificationId: Int!): Boolean!
   addAnnotationToShot(
     shotId: Int!
     annotationName: String!