@quesmed/types-rn 2.2.99 → 2.2.101

package/package.json

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

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

@@ -51,7 +51,7 @@ export interface IMarksheetInput {
  */
 export declare const SAVE_MARKSHEET: import("@apollo/client").DocumentNode;
 export declare const updateMarksheets: (cache: ApolloCache<any>, result: ApolloUpdateResultRestricted<ISaveMarksheetsData>, options: ApolloUpdateOptions) => void;
-export declare const optimisticSaveMarksheets: (client: ApolloClient<any>, marksheetInput: IMarksheetInput, questionIndex: number) => ISaveMarksheetsData;
+export declare const optimisticSaveMarksheets: (marksheet: IMarksheet, marksheetInput: IMarksheetInput, questionIndex: number) => ISaveMarksheetsData;
 export interface ISaveMarksheetsVar {
     marksheetInput: IMarksheetInput[];
 }

package/resolvers/mutation/restricted/marksheet.js

@@ -1781,36 +1781,24 @@ const updateMarksheets = (cache, result, options) => {
     }
 };
 exports.updateMarksheets = updateMarksheets;
-const optimisticSaveMarksheets = (client, marksheetInput, questionIndex) => {
+const optimisticSaveMarksheets = (marksheet, marksheetInput, questionIndex) => {
     const { timeTaken, choiceId, mark, marksheetId } = marksheetInput;
-    const data = client.readQuery({
-        variables: { id: marksheetId },
-        query: restricted_1.MARKSHEET,
-    });
-    const { marksheet } = data?.restricted || {};
-    if (marksheet) {
-        const { marks = [], ...rest } = marksheet || {};
-        const updatedMark = {
-            ...marks[questionIndex],
-            marksheetId,
-            timeTaken,
-            questionChoiceId: choiceId ?? null,
-            mark: mark || null,
-        };
-        const udatedMarks = [
-            ...marks.slice(0, questionIndex),
-            updatedMark,
-            ...marks.slice(questionIndex + 1),
-        ];
-        return {
-            restricted: {
-                saveMarksheets: [{ ...rest, marks: udatedMarks }],
-            },
-        };
-    }
+    const { marks = [], ...rest } = marksheet || {};
+    const updatedMark = {
+        ...marks[questionIndex],
+        marksheetId,
+        timeTaken,
+        questionChoiceId: choiceId ?? null,
+        mark: mark || null,
+    };
+    const udatedMarks = [
+        ...marks.slice(0, questionIndex),
+        updatedMark,
+        ...marks.slice(questionIndex + 1),
+    ];
     return {
         restricted: {
-            saveMarksheets: [],
+            saveMarksheets: [{ ...rest, marks: udatedMarks }],
         },
     };
 };

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

@@ -1,3 +1,5 @@
+import { ApolloCache } from '@apollo/client';
+import { ApolloUpdateOptions, ApolloUpdateResultRestricted } from '../..';
 import { Id, IMarksheet, IMarksheetMark } from '../../../models';
 import { graphqlNormalize, RestrictedData } from '../../types';
 export declare const BUILD_MOCK_TEST_MARKSHEET: import("@apollo/client").DocumentNode;
@@ -7,12 +9,74 @@ export interface IBuildMockTestMarksheetVar {
 }
 export declare type IBuildMockTestMarksheetData = RestrictedData<graphqlNormalize & IMarksheet, 'buildMockTestMarksheet'>;
 export declare const TOGGLE_FLAGGED_MARK: import("@apollo/client").DocumentNode;
+export declare const MARK_FLAGGED_QUESTION: import("@apollo/client").DocumentNode;
+export declare const updateCacheToggleFlaggedQuestion: (cache: ApolloCache<any>, result: ApolloUpdateResultRestricted<IToggleFlaggedMarkData>) => void;
+export declare const optimisticToggleFlaggedQuestion: (mark: IMarksheetMark, flagged: boolean) => {
+    restricted: {
+        __typename: string;
+        toggleFlaggedMark: {
+            flagged: boolean;
+            id: number;
+            createdAt: number | Date;
+            updatedAt: number | Date;
+            index: number;
+            marksheetId: number;
+            questionChoiceId: number | null;
+            questionChoices?: import("../../../models").IQuestionChoice | undefined;
+            timeTaken: number;
+            questionId: number;
+            question: import("../../../models").IQuestion;
+            mark: import("../../../models").IMarksheetMarkJSONB;
+            marksheet?: IMarksheet | undefined;
+            isAnswered: boolean;
+            striked: number[];
+        };
+    };
+};
 export interface IToggleFlaggedMarkVar {
     markId: Id;
     isFlagged: boolean;
 }
 export declare type IToggleFlaggedMarkData = RestrictedData<graphqlNormalize & IMarksheetMark, 'toggleFlaggedMark'>;
 export declare const END_MOCK_TEST: import("@apollo/client").DocumentNode;
+export declare const updateCacheOnEndMockTest: (cache: ApolloCache<any>, result: ApolloUpdateResultRestricted<IEndMockTestData>, options: ApolloUpdateOptions) => void;
+export declare const optimisticEndMockTest: (marksheet: IMarksheet) => {
+    restricted: {
+        __typename: string;
+        endMockTest: {
+            completed: boolean;
+            id: number;
+            createdAt: number | Date;
+            updatedAt: number | Date;
+            deletedAt: number | Date;
+            startedAt: number | Date;
+            type: import("../../../models").EMarksheetType;
+            endedAt: number | Date;
+            topicIds: number[];
+            topicNames?: string[] | undefined;
+            source: string;
+            userId: number;
+            user?: import("../../../models").IUser | undefined;
+            marks: IMarksheetMark[];
+            mockTestId: number | null;
+            correct?: number | undefined;
+            incorrect?: number | undefined;
+            totalQuestions?: number | undefined;
+            isTestMarksheet?: boolean | undefined;
+            solo: boolean;
+            agoraId: string;
+            users: import("../../../models").IUser[];
+            activeUsers?: import("../../../models").IUser[] | undefined;
+            state: import("../../../models").EMarksheetState;
+            timeTaken: number;
+            currentMarkId?: number | undefined;
+            topicConceptData?: string | undefined;
+            preBuildData?: import("./marksheet").IPreBuildMarksheet | undefined;
+            builderConfig?: import("./marksheet").IBuildConfigData | undefined;
+            __typename: string;
+        };
+    };
+};
 export interface IEndMockTestVar {
     marksheetId: Id;
 }

package/resolvers/mutation/restricted/mockTest.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.END_MOCK_TEST = exports.TOGGLE_FLAGGED_MARK = exports.BUILD_MOCK_TEST_MARKSHEET = void 0;
+exports.optimisticEndMockTest = exports.updateCacheOnEndMockTest = exports.END_MOCK_TEST = exports.optimisticToggleFlaggedQuestion = exports.updateCacheToggleFlaggedQuestion = exports.MARK_FLAGGED_QUESTION = exports.TOGGLE_FLAGGED_MARK = exports.BUILD_MOCK_TEST_MARKSHEET = void 0;
 const client_1 = require("@apollo/client");
 exports.BUILD_MOCK_TEST_MARKSHEET = (0, client_1.gql) `
   mutation BuildMockTestMarksheet($mockTestId: Int!, $duration: Int!) {
@@ -16,10 +16,41 @@ exports.TOGGLE_FLAGGED_MARK = (0, client_1.gql) `
     restricted {
       toggleFlaggedMark(markId: $markId, isFlagged: $isFlagged) {
         id
+        flagged
       }
     }
   }
 `;
+exports.MARK_FLAGGED_QUESTION = (0, client_1.gql) `
+  fragment MarksheetMarkFlagged on MarksheetMark {
+    flagged
+  }
+`;
+const updateCacheToggleFlaggedQuestion = (cache, result) => {
+    const { toggleFlaggedMark } = result?.data?.restricted || {};
+    if (!toggleFlaggedMark) {
+        return;
+    }
+    const { id, flagged } = toggleFlaggedMark;
+    cache.writeFragment({
+        id: cache.identify({ id, __typename: 'MarksheetMark' }),
+        data: {
+            flagged,
+        },
+        fragment: exports.MARK_FLAGGED_QUESTION,
+    });
+};
+exports.updateCacheToggleFlaggedQuestion = updateCacheToggleFlaggedQuestion;
+const optimisticToggleFlaggedQuestion = (mark, flagged) => ({
+    restricted: {
+        __typename: 'RestrictedMutation',
+        toggleFlaggedMark: {
+            ...mark,
+            flagged,
+        },
+    },
+});
+exports.optimisticToggleFlaggedQuestion = optimisticToggleFlaggedQuestion;
 exports.END_MOCK_TEST = (0, client_1.gql) `
   mutation EndMockTest($marksheetId: Int!) {
     restricted {
@@ -30,3 +61,35 @@ exports.END_MOCK_TEST = (0, client_1.gql) `
     }
   }
 `;
+const COMPLETED_MOCK_TEST_FRAGMENT = (0, client_1.gql) `
+  fragment MockTestCompleted on Marksheet {
+    completed
+  }
+`;
+const updateCacheOnEndMockTest = (cache, result, options) => {
+    const { endMockTest } = result?.data?.restricted || {};
+    const { variables } = options || {};
+    if (!variables || !endMockTest) {
+        return;
+    }
+    const { marksheetId: id } = variables;
+    cache.writeFragment({
+        id: cache.identify({ id, __typename: 'Marksheet' }),
+        data: {
+            completed: true,
+        },
+        fragment: COMPLETED_MOCK_TEST_FRAGMENT,
+    });
+};
+exports.updateCacheOnEndMockTest = updateCacheOnEndMockTest;
+const optimisticEndMockTest = (marksheet) => ({
+    restricted: {
+        __typename: 'RestrictedMutation',
+        endMockTest: {
+            __typename: 'Marksheet',
+            ...marksheet,
+            completed: true,
+        },
+    },
+});
+exports.optimisticEndMockTest = optimisticEndMockTest;