@quesmed/types-rn 2.2.90 → 2.2.92

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quesmed/types-rn",
-  "version": "2.2.90",
+  "version": "2.2.92",
   "description": "Typescript types for Quesmed",
   "keywords": [
     "quesmed",

package/resolvers/mutation/restricted/notification.d.ts

@@ -30,3 +30,33 @@ export declare const updateNotificatonsOnMarkAsRead: (cache: ApolloCache<any>, r
 export declare type IMarkAllNotificationsAsReadVar = null;
 export declare type IMarkAllNotificationsAsReadData = RestrictedData<graphqlNormalize & INotification[], 'markAllNotificationsAsRead'>;
 export declare const MARK_ALL_AS_READ: import("@apollo/client").DocumentNode;
+export declare const optimisticMarkAsRead: (notification: INotification) => () => {
+    restricted: {
+        __typename: string;
+        markNotificationAsRead: {
+            read: boolean;
+            id: number;
+            createdAt: number | Date;
+            updatedAt: number | Date;
+            deletedAt: number | Date;
+            userId: number | null;
+            user?: import("../../../models").IUser | undefined;
+            fromUserId: number | null;
+            fromUser?: import("../../../models").IUser | undefined;
+            commentId: number | null;
+            comment?: import("../../../models").IQuestionComment | undefined;
+            fromUserCommentId: number | null;
+            fromUserComment?: import("../../../models").IQuestionComment | undefined;
+            description: string;
+            actionType: ENotificationActionType;
+            type: ENotificationType;
+            global: boolean;
+        };
+    };
+};
+export declare const optimisticMarkAllAsRead: (notifications?: INotification[]) => () => {
+    restricted: {
+        __typename: string;
+        markAllNotificationsAsRead: INotification[];
+    };
+};

package/resolvers/mutation/restricted/notification.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MARK_ALL_AS_READ = exports.updateNotificatonsOnMarkAsRead = exports.MARK_AS_READ = void 0;
+exports.optimisticMarkAllAsRead = exports.optimisticMarkAsRead = exports.MARK_ALL_AS_READ = exports.updateNotificatonsOnMarkAsRead = exports.MARK_AS_READ = void 0;
 const client_1 = require("@apollo/client");
 const restricted_1 = require("../../query/restricted");
 exports.MARK_AS_READ = (0, client_1.gql) `
   mutation MarkNotificationAsread($id: Int!) {
     restricted {
       markNotificationAsRead(id: $id) {
-        actionType
         id
         read
       }
@@ -57,10 +56,40 @@ exports.MARK_ALL_AS_READ = (0, client_1.gql) `
   mutation MarkAllNotificationsAsRead {
     restricted {
       markAllNotificationsAsRead {
-        actionType
         id
         read
       }
     }
   }
 `;
+const optimisticMarkAsRead = (notification) => () => ({
+    restricted: {
+        __typename: 'RestrictedMutation',
+        markNotificationAsRead: {
+            ...notification,
+            read: true,
+        },
+    },
+});
+exports.optimisticMarkAsRead = optimisticMarkAsRead;
+const optimisticMarkAllAsRead = (notifications = []) => () => {
+    const index = notifications.findIndex(({ read }) => read);
+    const updatedNotification = notifications
+        .slice(0, index)
+        .map((notification) => ({ ...notification, read: true }));
+    return {
+        restricted: {
+            __typename: 'RestrictedMutation',
+            markAllNotificationsAsRead: [
+                ...updatedNotification,
+                ...notifications.slice(index).sort((n1, n2) => {
+                    if (n1.read === n2.read) {
+                        return n1.createdAt < n2.createdAt ? -1 : 1;
+                    }
+                    return n1.read ? 1 : -1;
+                }),
+            ],
+        },
+    };
+};
+exports.optimisticMarkAllAsRead = optimisticMarkAllAsRead;

package/resolvers/mutation/restricted/questionDiscussion.d.ts

@@ -9,15 +9,21 @@ interface LikeData {
 }
 export declare const getLikeData: (like: EQuestionLike, item: LikeData) => LikeData;
 export declare const getQuestionTypeName: (typeId: EQuestionType) => string;
+export declare const updatedCommentsOnAdd: (newComment: IQuestionComment, comments: IQuestionComment[], parentId?: number | undefined) => IQuestionComment[];
+export declare const updateCommentsOnRemove: (comments: IQuestionComment[], commentId: number, parentId?: number | undefined) => IQuestionComment[];
+export declare const updatedCommentsInMarksheetQuestion: (cache: ApolloCache<any>, questionComments: IQuestionComment, marksheetId: number, questionId: number, parentId?: number | undefined) => void;
+export declare const updatedCommentsInQuestion: (cache: ApolloCache<any>, questionComments: IQuestionComment, questionId: number, parentId?: number | undefined) => void;
+export declare const updatedRemoveCommentsInMarksheetQuestion: (cache: ApolloCache<any>, marksheetId: number, questionId: number, commentId: number, parentId?: number | undefined) => void;
+export declare const updatedRemoveCommentsInQuestion: (cache: ApolloCache<any>, questionId: number, commentId: number, parentId?: number | undefined) => void;
 export declare const QUESTION_LIKE: import("@apollo/client").DocumentNode;
-export declare const optimisticQuestionLike: (marksheetId: number, client: ApolloClient<any>, input: IQuestionLikeVar) => IQuestionLikeData;
+export declare const optimisticQuestionLike: (client: ApolloClient<any>, input: IQuestionLikeVar, marksheetId?: number | undefined) => IQuestionLikeData;
 export interface IQuestionLikeVar {
     questionId: Id;
     like: EQuestionLike;
 }
 export declare type IQuestionLikeData = RestrictedData<graphqlNormalize & IQuestion, 'questionLike'>;
 export declare const QUESTION_COMMENTS: import("@apollo/client").DocumentNode;
-export declare const updateQuestionComments: (marksheetId: number) => (cache: ApolloCache<any>, result: ApolloUpdateResultRestricted<IQuestionCommentsData>, options: ApolloUpdateOptions) => void;
+export declare const updateQuestionComments: (marksheetId?: number | undefined) => (cache: ApolloCache<any>, result: ApolloUpdateResultRestricted<IQuestionCommentsData>, options: ApolloUpdateOptions) => void;
 export declare const optimisticQuestionComment: (id: number, user: {
     id: number;
     displayName: string;
@@ -36,7 +42,7 @@ export interface IQuestionCommentsLikeVar {
 }
 export declare type IQuestionCommentsLikeData = RestrictedData<graphqlNormalize & IQuestionComment, 'questionCommentLike'>;
 export declare const QUESTION_COMMENT_REMOVE: import("@apollo/client").DocumentNode;
-export declare const updateQuestionCommentsRemove: (marksheetId: number) => (cache: ApolloCache<any>, result: ApolloUpdateResultRestricted<IQuestionCommentRemoveData>, options: ApolloUpdateOptions) => void;
+export declare const updateQuestionCommentsRemove: (marksheetId?: number | undefined) => (cache: ApolloCache<any>, result: ApolloUpdateResultRestricted<IQuestionCommentRemoveData>, options: ApolloUpdateOptions) => void;
 export declare const optimisticQuestionCommentRemove: (comments: IQuestionComment[], input: IQuestionCommentRemoveVar, parentId?: number | undefined) => IQuestionCommentRemoveData;
 export interface IQuestionCommentRemoveVar {
     commentId: Id;

package/resolvers/mutation/restricted/questionDiscussion.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.optimisticQuestionCommentRemove = exports.updateQuestionCommentsRemove = exports.QUESTION_COMMENT_REMOVE = exports.optimisticCommentLike = exports.QUESTION_COMMENT_LIKE = exports.optimisticQuestionComment = exports.updateQuestionComments = exports.QUESTION_COMMENTS = exports.optimisticQuestionLike = exports.QUESTION_LIKE = exports.getQuestionTypeName = exports.getLikeData = void 0;
+exports.optimisticQuestionCommentRemove = exports.updateQuestionCommentsRemove = exports.QUESTION_COMMENT_REMOVE = exports.optimisticCommentLike = exports.QUESTION_COMMENT_LIKE = exports.optimisticQuestionComment = exports.updateQuestionComments = exports.QUESTION_COMMENTS = exports.optimisticQuestionLike = exports.QUESTION_LIKE = exports.updatedRemoveCommentsInQuestion = exports.updatedRemoveCommentsInMarksheetQuestion = exports.updatedCommentsInQuestion = exports.updatedCommentsInMarksheetQuestion = exports.updateCommentsOnRemove = exports.updatedCommentsOnAdd = exports.getQuestionTypeName = exports.getLikeData = void 0;
 const client_1 = require("@apollo/client");
 const models_1 = require("../../../models");
 const restricted_1 = require("../../query/restricted");
@@ -43,6 +43,161 @@ const getQuestionTypeName = (typeId) => {
     }
 };
 exports.getQuestionTypeName = getQuestionTypeName;
+const updatedCommentsOnAdd = (newComment, comments, parentId) => {
+    if (parentId) {
+        const commentIndex = comments.findIndex(({ id }) => Number(id) === parentId);
+        const { replies = [], ...commentRest } = comments[commentIndex];
+        return [
+            ...comments.slice(0, commentIndex),
+            { ...commentRest, replies: [...replies, newComment] },
+            ...comments.slice(commentIndex + 1),
+        ];
+    }
+    return [...comments, newComment];
+};
+exports.updatedCommentsOnAdd = updatedCommentsOnAdd;
+const updateCommentsOnRemove = (comments, commentId, parentId) => {
+    if (parentId) {
+        const commentIndex = comments.findIndex(({ id }) => Number(id) === Number(parentId));
+        const { replies = [], ...commentRest } = comments[commentIndex];
+        return [
+            ...comments.slice(0, commentIndex),
+            {
+                ...commentRest,
+                replies: replies.filter(({ id }) => Number(id) !== Number(commentId)),
+            },
+            ...comments.slice(commentIndex + 1),
+        ];
+    }
+    return comments.filter(({ id }) => Number(id) !== Number(commentId));
+};
+exports.updateCommentsOnRemove = updateCommentsOnRemove;
+const updatedCommentsInMarksheetQuestion = (cache, questionComments, marksheetId, questionId, parentId) => {
+    const marksheetData = cache.readQuery({
+        variables: { id: marksheetId },
+        query: restricted_1.MARKSHEET,
+    });
+    if (marksheetData) {
+        const { marksheet } = marksheetData.restricted || {};
+        const { marks, ...marksheetRest } = marksheet;
+        const index = marks.findIndex(({ question }) => Number(question.id) === Number(questionId));
+        const { question, ...markRest } = marks[index];
+        const { comments = [], ...questionRest } = question;
+        cache.writeQuery({
+            query: restricted_1.MARKSHEET,
+            variables: { id: marksheetId },
+            data: {
+                ...marksheetData,
+                restricted: {
+                    ...marksheetData.restricted,
+                    marksheet: {
+                        ...marksheetRest,
+                        marks: [
+                            ...marks.slice(0, index),
+                            {
+                                ...markRest,
+                                question: {
+                                    ...questionRest,
+                                    comments: (0, exports.updatedCommentsOnAdd)(questionComments, comments, parentId),
+                                },
+                            },
+                            ...marks.slice(index + 1),
+                        ],
+                    },
+                },
+            },
+        });
+    }
+};
+exports.updatedCommentsInMarksheetQuestion = updatedCommentsInMarksheetQuestion;
+const updatedCommentsInQuestion = (cache, questionComments, questionId, parentId) => {
+    const questionData = cache.readQuery({
+        variables: { id: questionId },
+        query: restricted_1.QUESTION,
+    });
+    if (questionData) {
+        const { question } = questionData.restricted || {};
+        const { comments = [], ...questionRest } = question;
+        cache.writeQuery({
+            query: restricted_1.QUESTION,
+            variables: { id: questionId },
+            data: {
+                ...questionData,
+                restricted: {
+                    ...questionData.restricted,
+                    question: {
+                        ...questionRest,
+                        comments: (0, exports.updatedCommentsOnAdd)(questionComments, comments, parentId),
+                    },
+                },
+            },
+        });
+    }
+};
+exports.updatedCommentsInQuestion = updatedCommentsInQuestion;
+const updatedRemoveCommentsInMarksheetQuestion = (cache, marksheetId, questionId, commentId, parentId) => {
+    const marksheetData = cache.readQuery({
+        variables: { id: marksheetId },
+        query: restricted_1.MARKSHEET,
+    });
+    if (marksheetData) {
+        const { marksheet } = marksheetData.restricted || {};
+        const { marks, ...marksheetRest } = marksheet;
+        const index = marks.findIndex(({ question }) => Number(question.id) === Number(questionId));
+        const { question, ...markRest } = marks[index];
+        const { comments = [], ...questionRest } = question;
+        cache.writeQuery({
+            query: restricted_1.MARKSHEET,
+            variables: { id: marksheetId },
+            data: {
+                ...marksheetData,
+                restricted: {
+                    ...marksheetData.restricted,
+                    marksheet: {
+                        ...marksheetRest,
+                        marks: [
+                            ...marks.slice(0, index),
+                            {
+                                ...markRest,
+                                question: {
+                                    ...questionRest,
+                                    comments: (0, exports.updateCommentsOnRemove)(comments, commentId, parentId),
+                                },
+                            },
+                            ...marks.slice(index + 1),
+                        ],
+                    },
+                },
+            },
+        });
+    }
+};
+exports.updatedRemoveCommentsInMarksheetQuestion = updatedRemoveCommentsInMarksheetQuestion;
+const updatedRemoveCommentsInQuestion = (cache, questionId, commentId, parentId) => {
+    const questionData = cache.readQuery({
+        variables: { id: questionId },
+        query: restricted_1.QUESTION,
+    });
+    if (questionData) {
+        const { question } = questionData.restricted || {};
+        const { comments = [], ...questionRest } = question;
+        cache.writeQuery({
+            query: restricted_1.QUESTION,
+            variables: { id: questionId },
+            data: {
+                ...questionData,
+                restricted: {
+                    ...questionData.restricted,
+                    question: {
+                        ...questionRest,
+                        comments: (0, exports.updateCommentsOnRemove)(comments, commentId, parentId),
+                    },
+                },
+            },
+        });
+    }
+};
+exports.updatedRemoveCommentsInQuestion = updatedRemoveCommentsInQuestion;
 exports.QUESTION_LIKE = (0, client_1.gql) `
   mutation QuestionLike($questionId: Int!, $like: Int!) {
     restricted {
@@ -56,16 +211,25 @@ exports.QUESTION_LIKE = (0, client_1.gql) `
     }
   }
 `;
-const optimisticQuestionLike = (marksheetId, client, input) => {
+const optimisticQuestionLike = (client, input, marksheetId) => {
     const { questionId, like } = input;
-    const data = client.readQuery({
-        variables: { id: marksheetId },
-        query: restricted_1.MARKSHEET,
-    });
-    const { marksheet } = data?.restricted || {};
-    const { marks = [] } = marksheet || {};
-    const { question } = marks.find(({ question }) => Number(question.id) === Number(questionId)) ||
-        {};
+    let question;
+    if (marksheetId) {
+        const data = client.readQuery({
+            variables: { id: marksheetId },
+            query: restricted_1.MARKSHEET,
+        });
+        const { marksheet } = data?.restricted || {};
+        const { marks = [] } = marksheet || {};
+        question = marks.find(({ question }) => Number(question.id) === Number(questionId))?.question;
+    }
+    else {
+        const data = client.readQuery({
+            variables: { id: Number(questionId) },
+            query: restricted_1.QUESTION,
+        });
+        question = data?.restricted.question;
+    }
     if (question) {
         const { typeId } = question;
         return {
@@ -131,50 +295,11 @@ const updateQuestionComments = (marksheetId) => (cache, result, options) => {
     }
     const { questionId, parentId } = variables;
     try {
-        const prevData = cache.readQuery({
-            variables: { id: marksheetId },
-            query: restricted_1.MARKSHEET,
-        });
-        if (prevData) {
-            const { marksheet } = prevData.restricted || {};
-            const { marks, ...marksheetRest } = marksheet;
-            const index = marks.findIndex(({ question }) => Number(question.id) === Number(questionId));
-            const { question, ...markRest } = marks[index];
-            const { comments = [], ...questionRest } = question;
-            let newComments;
-            if (parentId) {
-                const commentIndex = comments.findIndex(({ id }) => Number(id) === parentId);
-                const { replies = [], ...commentRest } = comments[commentIndex];
-                newComments = [
-                    ...comments.slice(0, commentIndex),
-                    { ...commentRest, replies: [...replies, questionComments] },
-                    ...comments.slice(commentIndex + 1),
-                ];
-            }
-            else {
-                newComments = [...comments, questionComments];
-            }
-            cache.writeQuery({
-                query: restricted_1.MARKSHEET,
-                variables: { id: marksheetId },
-                data: {
-                    ...prevData,
-                    restricted: {
-                        ...prevData.restricted,
-                        marksheet: {
-                            ...marksheetRest,
-                            marks: [
-                                ...marks.slice(0, index),
-                                {
-                                    ...markRest,
-                                    question: { ...questionRest, comments: newComments },
-                                },
-                                ...marks.slice(index + 1),
-                            ],
-                        },
-                    },
-                },
-            });
+        if (marksheetId) {
+            (0, exports.updatedCommentsInMarksheetQuestion)(cache, questionComments, marksheetId, questionId, parentId);
+        }
+        else {
+            (0, exports.updatedCommentsInQuestion)(cache, questionComments, questionId, parentId);
         }
     }
     catch (error) {
@@ -299,53 +424,11 @@ const updateQuestionCommentsRemove = (marksheetId) => (cache, result, options) =
     }
     const { questionId, id: commentId, parentId } = questionCommentRemove;
     try {
-        const prevData = cache.readQuery({
-            variables: { id: marksheetId },
-            query: restricted_1.MARKSHEET,
-        });
-        if (prevData) {
-            const { marksheet } = prevData.restricted || {};
-            const { marks, ...marksheetRest } = marksheet;
-            const index = marks.findIndex(({ question }) => Number(question.id) === Number(questionId));
-            const { question, ...markRest } = marks[index];
-            const { comments = [], ...questionRest } = question;
-            let newComments;
-            if (parentId) {
-                const commentIndex = comments.findIndex(({ id }) => Number(id) === Number(parentId));
-                const { replies = [], ...commentRest } = comments[commentIndex];
-                newComments = [
-                    ...comments.slice(0, commentIndex),
-                    {
-                        ...commentRest,
-                        replies: replies.filter(({ id }) => Number(id) !== Number(commentId)),
-                    },
-                    ...comments.slice(commentIndex + 1),
-                ];
-            }
-            else {
-                newComments = comments.filter(({ id }) => Number(id) !== Number(commentId));
-            }
-            cache.writeQuery({
-                query: restricted_1.MARKSHEET,
-                variables: { id: marksheetId },
-                data: {
-                    ...prevData,
-                    restricted: {
-                        ...prevData.restricted,
-                        marksheet: {
-                            ...marksheetRest,
-                            marks: [
-                                ...marks.slice(0, index),
-                                {
-                                    ...markRest,
-                                    question: { ...questionRest, comments: newComments },
-                                },
-                                ...marks.slice(index + 1),
-                            ],
-                        },
-                    },
-                },
-            });
+        if (marksheetId) {
+            (0, exports.updatedRemoveCommentsInMarksheetQuestion)(cache, marksheetId, questionId, commentId, parentId);
+        }
+        else {
+            (0, exports.updatedRemoveCommentsInQuestion)(cache, questionId, commentId, parentId);
         }
     }
     catch (error) {