@quesmed/types 1.5.7 → 1.6.1

package/dist/cjs/utils/lightgallery.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lightgalleryOsceResolve = void 0;
+const lightgalleryRegex = /\[lightgallery\]/;
+function isOsceMarksheet(data) {
+    return 'osceStationId' in data;
+}
+async function lightgalleryOsceResolve(data, cache) {
+    let station;
+    if (isOsceMarksheet(data)) {
+        if (!data.osceStation) {
+            throw new Error('OsceStation not found on OsceMarksheet');
+        }
+        station = data.osceStation;
+    }
+    else {
+        station = data;
+    }
+    const upOsceStation = {
+        candidateBrief: station.candidateBrief,
+        actorBrief: station.actorBrief,
+        examinerBrief: station.examinerBrief,
+        explanation: station.explanation,
+    };
+    if (station.candidatePictures && station.candidatePictures.length > 0) {
+        upOsceStation.candidateBrief = await lightgalleryMutation(upOsceStation.candidateBrief, station.candidatePictures, cache);
+    }
+    if (station.actorPictures && station.actorPictures.length > 0) {
+        upOsceStation.actorBrief = await lightgalleryMutation(upOsceStation.actorBrief, station.actorPictures, cache);
+    }
+    if (station.examinerPictures && station.examinerPictures.length > 0) {
+        upOsceStation.examinerBrief = await lightgalleryMutation(upOsceStation.examinerBrief, station.examinerPictures, cache);
+    }
+    if (station.walkthroughPictures && station.walkthroughPictures.length > 0) {
+        upOsceStation.explanation = await lightgalleryMutation(upOsceStation.explanation, station.walkthroughPictures, cache);
+    }
+    if (isOsceMarksheet(data)) {
+        return {
+            ...data,
+            osceStation: {
+                ...data.osceStation,
+                ...upOsceStation,
+            },
+        };
+    }
+    else {
+        return {
+            ...data,
+            ...upOsceStation,
+        };
+    }
+}
+exports.lightgalleryOsceResolve = lightgalleryOsceResolve;
+const lightgalleryMutation = async (text, pictures, cache) => {
+    if (pictures.length === 0) {
+        return text;
+    }
+    const picturesHTML = [];
+    for (const { picture } of pictures) {
+        const pic = picture.path;
+        const uri = `https://app.quesmed.com/${pic}`;
+        let file = '';
+        if (cache) {
+            try {
+                const localPath = await cache.CacheManager.get(uri, {}).getPath();
+                if (localPath) {
+                    file =
+                        cache.Platform.OS === 'ios'
+                            ? localPath.replace('file://', '')
+                            : localPath;
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        if (picture.caption?.length > 0) {
+            picturesHTML.push(`![${file}](${uri} "${picture.caption}")`);
+        }
+        picturesHTML.push(`![${file}](${uri})`);
+    }
+    if (lightgalleryRegex.test(text)) {
+        return text.replace(lightgalleryRegex, picturesHTML[0]);
+    }
+    else {
+        return text + '\n\n' + picturesHTML[0] + '\n';
+    }
+};

package/dist/cjs/utils/offlineLink.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfflineLink = void 0;
+const client_1 = require("@apollo/client");
+const uuid4_1 = __importDefault(require("./uuid4"));
+class OfflineLink extends client_1.ApolloLink {
+    /**
+     * storage
+     * Provider that will persist the mutation queue. This can be any AsyncStorage compatible storage instance.
+     *
+     * retryInterval
+     * Milliseconds between attempts to retry failed mutations. Defaults to 0, which disables automatic retry.
+     *
+     * sequential
+     * Indicates if the attempts should be retried in order. Defaults to false which retries all failed mutations in parallel.
+     *
+     * retryOnServerError
+     * Indicates if mutations should be reattempted if there are server side errors, useful to retry mutations on session expiration. Defaults to false.
+     */
+    constructor({ storage, retryInterval = 0, sequential = false, retryOnServerError = false, }) {
+        super();
+        this.queue = new Map();
+        this.prefix = 'offlineLink:';
+        if (!storage) {
+            throw new Error('Storage is required, it can be an AsyncStorage compatible storage instance.');
+        }
+        this.storage = storage;
+        this.sequential = sequential;
+        this.retryInterval = retryInterval;
+        this.retryOnServerError = retryOnServerError;
+    }
+    request(operation, forward) {
+        const context = operation.getContext();
+        const { query, variables } = operation || {};
+        if (!context.optimisticResponse) {
+            // If the mutation does not have an optimisticResponse then we can't defer it
+            return forward(operation);
+        }
+        return new client_1.Observable((observer) => {
+            const mutationId = uuid4_1.default.asBase64();
+            this.add({
+                mutation: query,
+                variables,
+                optimisticResponse: context.optimisticResponse,
+            }, mutationId);
+            const subscription = forward(operation).subscribe({
+                next: (result) => {
+                    this.remove(mutationId);
+                    observer.next(result);
+                },
+                error: () => {
+                    // Mutation failed so we try again after a certain amount of time.
+                    this.delayedSync();
+                    // Resolve the mutation with the optimistic response so the UI can be updated
+                    observer.next({
+                        data: context.optimisticResponse,
+                        dataPresent: true,
+                        errors: [],
+                    });
+                    // Say we're all done so the UI is re-rendered.
+                    observer.complete();
+                },
+                complete: () => observer.complete(),
+            });
+            return () => {
+                subscription.unsubscribe();
+            };
+        });
+    }
+    /**
+     * Obtains the queue of mutations that must be sent to the server.
+     * These are kept in a Map to preserve the order of the mutations in the queue.
+     */
+    async getQueue() {
+        const map = new Map();
+        try {
+            const storedMutations = await this.storage.getItem(this.prefix + 'Mutations');
+            if (!storedMutations) {
+                return map;
+            }
+            const mutationIds = storedMutations.split(',');
+            for (const mutationId of mutationIds) {
+                const storedMutation = await this.storage.getItem(this.prefix + mutationId);
+                if (!storedMutation) {
+                    continue;
+                }
+                map.set(mutationId, JSON.parse(storedMutation));
+            }
+            return map;
+        }
+        catch (e) {
+            console.error(e);
+            return map;
+        }
+    }
+    /**
+     * Persist the queue so mutations can be retried at a later point in time.
+     */
+    async saveQueue(mutationId, mutation) {
+        try {
+            if (mutationId && mutation) {
+                await this.storage.setItem(this.prefix + mutationId, JSON.stringify(mutation));
+            }
+            await this.storage.setItem(this.prefix + 'Mutations', [...this.queue.keys()].join());
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    /**
+     * Add a mutation attempt to the queue so that it can be retried at a later point in time.
+     */
+    async add(item, mutationId) {
+        // We give the mutation attempt a random id so that it is easy to remove when needed (in sync loop)
+        if (!mutationId) {
+            mutationId = uuid4_1.default.asBase64();
+        }
+        this.queue.set(mutationId, item);
+        await this.saveQueue(mutationId, item);
+        return mutationId;
+    }
+    /**
+     * Remove a mutation attempt from the queue.
+     */
+    async remove(mutationId) {
+        this.queue.delete(mutationId);
+        await this.storage.removeItem(this.prefix + mutationId);
+        await this.saveQueue();
+    }
+    /**
+     * Takes the mutations in the queue and try to send them to the server again.
+     */
+    async sync() {
+        if (!this.client) {
+            throw new Error('Offline Link not setup with ApolloClient');
+        }
+        if (this.queue.size === 0) {
+            return;
+        }
+        const attempts = Array.from(this.queue);
+        if (this.sequential) {
+            for (const [mutationId, attempt] of attempts) {
+                let serverProcessed = false;
+                try {
+                    await this.client.mutate({
+                        ...attempt,
+                        optimisticResponse: undefined,
+                    });
+                    serverProcessed = true;
+                }
+                catch (e) {
+                    const err = e;
+                    const networkError = err.networkError;
+                    if (!this.retryOnServerError && networkError?.response) {
+                        // There are GraphQL errors, which means the server processed the request so we can remove the mutation from the queue
+                        serverProcessed = true;
+                    }
+                }
+                if (serverProcessed) {
+                    try {
+                        await this.remove(mutationId);
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }
+            }
+        }
+        else {
+            await Promise.all(attempts.map(async ([mutationId, attempt]) => {
+                let serverProcessed = false;
+                try {
+                    await this.client?.mutate({
+                        ...attempt,
+                        optimisticResponse: undefined,
+                    });
+                    serverProcessed = true;
+                }
+                catch (e) {
+                    const err = e;
+                    const networkError = err.networkError;
+                    if (!this.retryOnServerError && networkError?.response) {
+                        serverProcessed = true;
+                    }
+                }
+                if (serverProcessed) {
+                    await this.remove(mutationId);
+                }
+            }));
+        }
+        // Remaining mutations in the queue are persisted
+        await this.saveQueue();
+        if (this.queue.size !== 0 || this.retryInterval !== 0) {
+            this.delayedSync();
+        }
+    }
+    /**
+     * Runs sync() after the retryInterval
+     */
+    delayedSync() {
+        if (this.retryInterval === 0) {
+            return;
+        }
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
+        }
+        this.timeoutId = setTimeout(() => this.sync, this.retryInterval);
+    }
+    /**
+     * Configure the link to use Apollo Client and immediately try to sync the queue (if there's anything there).
+     */
+    async setup(client) {
+        this.client = client;
+        this.queue = await this.getQueue();
+        await this.sync();
+    }
+}
+exports.OfflineLink = OfflineLink;

package/{utils → dist/cjs/utils}/uuid4.js

@@ -182,7 +182,7 @@ class Uuid4 {
      * @private
      */
     static _asBinString(data) {
-        let binArray = data !== null && data !== void 0 ? data : Uuid4._getRandomArray();
+        let binArray = data ?? Uuid4._getRandomArray();
         if (16 !== binArray.length) {
             const mess = `Expected data array length of 16 but was given length: ${binArray.length}`;
             throw new RangeError(mess);

package/{utils → dist/cjs/utils}/webSocketLink.js

@@ -11,7 +11,7 @@ class WebSocketLink extends core_1.ApolloLink {
     }
     request(operation) {
         return new core_1.Observable((sink) => {
-            return this.client.subscribe(Object.assign(Object.assign({}, operation), { query: (0, graphql_1.print)(operation.query) }), {
+            return this.client.subscribe({ ...operation, query: (0, graphql_1.print)(operation.query) }, {
                 next: sink.next.bind(sink),
                 complete: sink.complete.bind(sink),
                 error: sink.error.bind(sink),

package/dist/mjs/gql_input_output_types/User.d.ts

@@ -0,0 +1,12 @@
+export interface ILoginUserRes {
+    token: string;
+    stripeCustomerPortalUrl: string;
+    message: string;
+}
+export interface IWithToken {
+    token: string;
+}
+export interface ILoginWithExpiredSupportRes {
+    activeUser: IWithToken | null;
+    expiredUser: IWithToken | null;
+}

package/dist/mjs/gql_input_output_types/index.d.ts

@@ -0,0 +1,75 @@
+import { IChapter, Id, IVideo } from '../models';
+import { RegisterUserInput } from '../resolvers/mutation/users';
+export interface TokenI {
+    firstName: string;
+    lastName: string;
+    username: string;
+    iat: number;
+    exp: number;
+}
+export interface UserTopicQuestionsInfo {
+    question: number;
+    correctQuestions: number;
+    incorrectQuestions: number;
+}
+export interface UserTopicCardsInfo {
+    cardCount: number;
+    ConfidentCards: number;
+    ReviewCards: number;
+    LearnCards: number;
+}
+export interface TodoInfo {
+    id: Id;
+    todoId: Id;
+    cardId: Id;
+    question: string;
+    explanation: string;
+    score: number;
+    timeTaken: number;
+    dailyTask: boolean;
+    source: string;
+}
+export interface ISearchConcepts {
+    id: number;
+    name: string;
+    chapter: IChapter;
+    topicId: number;
+    videos: IVideo[];
+}
+export interface IQuesBook {
+    id: number;
+    name: string;
+    concepts: ISearchConcepts[];
+}
+export interface LineItemI {
+    price: string;
+    quantity: number;
+}
+export interface CheckoutSessionArgsI {
+    priceId: string;
+    data: RegisterUserInput;
+}
+export interface IUniversityCalculation {
+    universityId: number;
+    specialityTopicId: number;
+    specialityTopicCorrect: number;
+    totalCorrect: number;
+    totalIncorrect: number;
+    totalCount: number;
+    rank: number;
+}
+export interface IUniversityCalculationMap {
+    [key: number]: IUniversityCalculation;
+}
+export interface IQuestionLike {
+    like: number;
+    dislike: number;
+}
+export interface ICheckoutSessionRes {
+    sessionId: string;
+    tempUserId: number;
+}
+export interface WithError {
+    error: string;
+    isError: boolean;
+}

package/dist/mjs/index.d.ts

@@ -0,0 +1,22 @@
+export * as Models from './models';
+export * from './resolvers';
+export * as utils from './utils';
+export declare const ERRORS: {
+    TOKEN_INVALID: string;
+    TOKEN_MISSING: string;
+    TOKEN_EXPIRED: string;
+    SUBSCRIPTION_EXPIRED: string;
+    PERMISSION_INVALID: string;
+};
+export declare const FCM_TOPICS: {
+    GLOBAL: string;
+    QBANK: string;
+    OSCE: string;
+};
+export declare enum EPlatformId {
+    QBANK = 0,
+    OSCE = 1
+}
+export declare const termsAndConditions = "# Group Study Conduct Policy\n\nAs future clinicians, we expect that you treat your colleagues fairly and with respect.\nAs a result, we will not tolerate the following actions during use of the Quesmed platform:\n\n- Violent threats\n- Wishing, hoping or calling for serious harm on a person or group of people\n- Incitement against individuals or groups\n- Slurs, racist and sexist tropes\n- Degrading others\n- Unwanted sexual advances\n\nWhen determining the penalty for violating our conduct policy, we consider a number of factors including the severity of the violation and the individual's record of violations. We reserve the right to immediately de-activate any account that violates our conduct policy. We may also consider raising concerns to the individual's licensing body (e.g. GMC) on a case-by-case basis.\n\nBy using the platform, you agree to be bound by our conduct policy as described above.";
+export declare const medicalWords: string[][];
+export declare function generateDisplayName(firstName: string, lastName: string): string;

package/dist/mjs/models/Author.d.ts

@@ -0,0 +1,14 @@
+import { Id } from './Type';
+export interface IAuthor {
+    id: Id;
+    createdAt: number | Date;
+    updatedAt: number | Date;
+    name: string;
+    qualifications: string | null;
+    title: string;
+    description: string;
+    avatar: string;
+    linkedIn: string;
+    twitter: string;
+    facebook: string;
+}

package/dist/mjs/models/Blog.d.ts

@@ -0,0 +1,15 @@
+import { Id } from './Type';
+export interface IBlogTag {
+    id: Id;
+    createdAt: number | Date;
+    name: string;
+}
+export interface IBlogPost {
+    id: Id;
+    createdAt: number | Date;
+    updatedAt: number | Date;
+    title: string;
+    body: string;
+    tags?: IBlogTag[];
+    relatedBlogPosts?: IBlogPost[];
+}

package/dist/mjs/models/Book.d.ts

@@ -0,0 +1,22 @@
+import { IAuthor } from './Author';
+import { Id } from './Type';
+export interface IBook {
+    id: Id;
+    createdAt: number | Date;
+    updatedAt: number | Date;
+    name: string;
+    publisher: string;
+    publishDate: number | Date;
+    pages: number;
+    format: string;
+    language: string;
+    type: string;
+    ISBN: number;
+    price: number;
+    avatar: string;
+    heroImg: string;
+    description: string;
+    chapters: string | string[];
+    stripePriceId: string;
+    authors: IAuthor[];
+}

package/dist/mjs/models/Card.d.ts

@@ -0,0 +1,16 @@
+import { IConcept } from './Concept';
+import { ICardPicture } from './Picture';
+import { ITopic } from './Topic';
+import { Id } from './Type';
+export interface ICard {
+    id: Id;
+    createdAt: number | Date;
+    updatedAt: number | Date;
+    topic: ITopic;
+    conceptId: Id;
+    concept: IConcept;
+    question: string;
+    explanation: string;
+    public: boolean;
+    pictures: ICardPicture[];
+}

package/dist/mjs/models/Chapter.d.ts

@@ -0,0 +1,13 @@
+import { IFile } from './File';
+import { IChapterPicture } from './Picture';
+import { ETopicType } from './Topic';
+import { Id } from './Type';
+export interface IChapter {
+    id: Id;
+    createdAt: number | Date;
+    updatedAt: number | Date;
+    explanation: string | null;
+    typeId: ETopicType | null;
+    pictures: IChapterPicture[];
+    files: IFile[];
+}

package/dist/mjs/models/Concept.d.ts

@@ -0,0 +1,23 @@
+import { IChapter } from './Chapter';
+import { ITopic } from './Topic';
+import { Id } from './Type';
+import { IVideo } from './Video';
+export interface IConcept {
+    id: Id;
+    createdAt: number | Date;
+    updatedAt: number | Date;
+    name: string;
+    chapterId: Id;
+    chapter: IChapter;
+    topicId: Id;
+    topic?: ITopic;
+    videos?: IVideo[];
+}
+export interface IAnatomyConcept {
+    id: number;
+    name: string;
+    totalCards: number;
+    ConfidentCards: number;
+    ReviewCards: number;
+    LearnCards: number;
+}

package/dist/mjs/models/Difficulty.d.ts

@@ -0,0 +1,6 @@
+export declare enum EDifficultyType {
+    ALL = 0,
+    CORE = 1,
+    CHALLENGING = 2,
+    DIFFICULT = 3
+}

package/dist/mjs/models/Feedback.d.ts

@@ -0,0 +1,8 @@
+import { Id } from './Type';
+export interface IFeedback {
+    id: Id;
+    createdAt: number | Date;
+    name: string;
+    feedback: string;
+    university: string;
+}

package/dist/mjs/models/File.d.ts

@@ -0,0 +1,10 @@
+import { Id } from './Type';
+export interface IFile {
+    id: Id;
+    createdAt: number | Date;
+    updatedAt: number | Date;
+    title: string;
+    url: string;
+    videoId?: number;
+    chapterId?: number;
+}

package/dist/mjs/models/Marksheet.d.ts

@@ -0,0 +1,47 @@
+import { IPrescribeMark, IQuestion, IQuestionQAAnswer } from './Question';
+import { Id } from './Type';
+export interface IMarksheet {
+    id: Id;
+    createdAt: number | Date;
+    endedAt: number | Date;
+    source: string;
+    marks: IMarksheetMark[];
+    mockTestId: number | null;
+}
+export declare enum EQuestionLike {
+    NONE = 0,
+    LIKE = 1,
+    DISLIKE = 2
+}
+export declare type IMarksheetMarkJSONB = string | [string] | [IQuestionQAAnswer] | [string[], string[]] | [IPrescribeMark] | null;
+export interface IMarksheetMark {
+    id: Id;
+    index: number;
+    marksheetId: Id;
+    questionChoiceId: Id;
+    timeTaken: number;
+    flagged: boolean;
+    questionId: Id;
+    question: IQuestion;
+    mark: IMarksheetMarkJSONB;
+    like: number;
+    dislike: number;
+    isLikeByMe: EQuestionLike;
+    discussion: IDiscussion[];
+}
+export interface IDiscussion {
+    username: string;
+    userId: Id;
+    createdAt: number | Date;
+    comment: string;
+    like: number;
+    dislike: number;
+    isLikeByMe: EQuestionLike;
+    commentId: number;
+    questionId: number;
+    reply: IDiscussion[];
+}
+export interface ILikeDislikeCount {
+    like: number;
+    dislike: number;
+}