@quesmed/types 1.5.9 → 2.0.0

package/{resolvers → dist/cjs/resolvers}/query/restricted/quesBook.d.ts

@@ -1,7 +1,7 @@
 import { IOsceStation, ITopic } from '../../../models';
 import { graphqlNormalize, RestrictedData } from '../../types';
 export declare type IQuesBookVar = null;
-export declare type IQuesBookData = ITopic[];
+export declare type IQuesBookData = RestrictedData<(graphqlNormalize & ITopic)[], 'quesBook'>;
 export declare const OSCE_BOOK: import("@apollo/client").DocumentNode;
 export declare type IOsceBookVar = null;
 export declare type IOsceBookData = RestrictedData<(graphqlNormalize & IOsceStation)[], 'osceBook'>;

package/{resolvers → dist/cjs/resolvers}/query/restricted/replication.d.ts

@@ -1,5 +1,4 @@
-import { IOsceStation, IQuestion } from './../../../models';
-import { ITopicInfo } from './topics';
+import { IOsceStation, IQuestion, ITopic } from './../../../models';
 interface IQueryBuilder {
     query: string;
     variables: IReplicationVar;
@@ -11,7 +10,7 @@ interface IReplicationVar {
 }
 export interface ITopicReplicationVar extends IReplicationVar {
 }
-export interface ITopicReplicationData extends ITopicInfo {
+export interface ITopicReplicationData extends ITopic {
     updatedAt: number;
     deleted: boolean;
 }

package/{resolvers → dist/cjs/resolvers}/query/restricted/replication.js

@@ -21,8 +21,8 @@ const pullTopicQueryBuilder = (doc) => {
     return {
         query: topicReplicationQuery,
         variables: {
-            lastId: (doc === null || doc === void 0 ? void 0 : doc.id) ? doc.id.toString() : '0',
-            minUpdatedAt: (doc === null || doc === void 0 ? void 0 : doc.updatedAt) ? doc.updatedAt : 0,
+            lastId: doc?.id ? doc.id.toString() : '0',
+            minUpdatedAt: doc?.updatedAt ? doc.updatedAt : 0,
             limit: REPLICATION_LIMIT,
         },
     };
@@ -92,8 +92,8 @@ const pullQuestionQueryBuilder = (doc) => {
     return {
         query: questionReplicationQuery,
         variables: {
-            lastId: (doc === null || doc === void 0 ? void 0 : doc.id) ? doc.id.toString() : '0',
-            minUpdatedAt: (doc === null || doc === void 0 ? void 0 : doc.updatedAt) ? doc.updatedAt : 0,
+            lastId: doc?.id ? doc.id.toString() : '0',
+            minUpdatedAt: doc?.updatedAt ? doc.updatedAt : 0,
             limit: REPLICATION_LIMIT,
         },
     };
@@ -175,8 +175,8 @@ const pullOsceStationQueryBuilder = (doc) => {
     return {
         query: osceStationReplicationQuery,
         variables: {
-            lastId: (doc === null || doc === void 0 ? void 0 : doc.id) ? doc.id.toString() : '0',
-            minUpdatedAt: (doc === null || doc === void 0 ? void 0 : doc.updatedAt) ? doc.updatedAt : 0,
+            lastId: doc?.id ? doc.id.toString() : '0',
+            minUpdatedAt: doc?.updatedAt ? doc.updatedAt : 0,
             limit: REPLICATION_LIMIT,
         },
     };

package/{resolvers → dist/cjs/resolvers}/query/restricted/todos.d.ts

@@ -1,4 +1,5 @@
 import { Id, IPreBuildTodo, ITodo } from '../../../models';
+import { graphqlNormalize, RestrictedData } from '../../types';
 export interface IPreBuildTodoVar {
     topics: number[];
     conceptIds: number[];
@@ -6,11 +7,11 @@ export interface IPreBuildTodoVar {
     source: string;
     filterOlderCard: boolean;
 }
-export declare type IPreBuildTodoData = IPreBuildTodo;
-export interface IGetTodoInfoVar {
-    todoId: Id;
+export declare type IPreBuildTodoData = RestrictedData<graphqlNormalize & IPreBuildTodo, 'preBuildTodo'>;
+export interface ITodoVar {
+    id: Id;
 }
-export declare type IGetTodoInfoData = ITodo;
+export declare type ITodoData = RestrictedData<graphqlNormalize & ITodo, 'todo'>;
 export declare type IDailyFeedVar = null;
 interface IDailyFeedTopicInfo {
     name: string;
@@ -24,5 +25,5 @@ export interface IDailyFeed {
     confidentCard: number;
     reviewCard: number;
 }
-export declare type IDailyFeedData = IDailyFeed;
+export declare type IDailyFeedData = RestrictedData<graphqlNormalize & IDailyFeed, 'dailyFeed'>;
 export {};

package/dist/cjs/resolvers/query/restricted/topics.d.ts

@@ -0,0 +1,10 @@
+import { ETopicType, Id, ITopic } from '../../../models';
+import { graphqlNormalize, RestrictedData } from '../../types';
+export interface ITopicVar {
+    id: Id;
+}
+export declare type ITopicData = RestrictedData<graphqlNormalize & ITopic, 'topic'>;
+export interface ITopicsVar {
+    filter: ETopicType;
+}
+export declare type ITopicsData = RestrictedData<(graphqlNormalize & ITopic)[], 'topics'>;

package/{resolvers → dist/cjs/resolvers}/query/restricted/university.d.ts

@@ -1,3 +1,4 @@
+import { graphqlNormalize, RestrictedData } from '../../types';
 export interface IUniversityLeaderboardVar {
     limit: number;
 }
@@ -11,5 +12,4 @@ export interface IUniversityLeaderboard {
     month: IUniversitiesRankSpeciality[];
     quarter: IUniversitiesRankSpeciality[];
 }
-export interface IUniversityLeaderboardData extends IUniversityLeaderboard {
-}
+export declare type IUniversityLeaderboardData = RestrictedData<graphqlNormalize & IUniversityLeaderboard, 'universityLeaderboard'>;

package/dist/cjs/resolvers/query/restricted/user.d.ts

@@ -0,0 +1,13 @@
+import { IUser } from '../../../models';
+import { graphqlNormalize, RestrictedData } from '../../types';
+export declare type IDashboardUserVar = null;
+export declare type IDashboardUserData = RestrictedData<graphqlNormalize & IUser, 'dashboardUser'>;
+export declare type IUserVar = null;
+export declare type IUserData = RestrictedData<graphqlNormalize & IUser, 'user'>;
+export declare type IDailyProgressVar = null;
+export interface IDailyProgressInfo {
+    totalCount: number;
+    totalTrue: number;
+    dateString: string;
+}
+export declare type IDailyProgressData = RestrictedData<(graphqlNormalize & IDailyProgressInfo)[], 'dailyProgress'>;

package/dist/cjs/resolvers/query/restricted/video.d.ts

@@ -0,0 +1,11 @@
+import { Id, IVideo } from '../../../models';
+import { graphqlNormalize, RestrictedData } from '../../types';
+export interface IVideoVar {
+    id: Id;
+}
+export declare type IVideoData = RestrictedData<graphqlNormalize & IVideo, 'video'>;
+export interface IVideosVar {
+    filter: 'new' | 'popular' | 'personal' | 'live' | 'osce';
+    limit: number;
+}
+export declare type IVideosData = RestrictedData<(graphqlNormalize & IVideo)[], 'videos'>;

package/dist/cjs/resolvers/query/subscription.d.ts

@@ -0,0 +1,3 @@
+import { ISubscription } from '../../models';
+import { graphqlNormalize, RootData } from '../types';
+export declare type ISubscriptionsData = RootData<(graphqlNormalize & ISubscription)[], 'subscriptions'>;

package/dist/cjs/resolvers/query/university.d.ts

@@ -0,0 +1,6 @@
+import { Id, IUniversity } from '../../models';
+import { graphqlNormalize, RootData } from '../types';
+export interface IUniversitiesVar {
+    id: Id;
+}
+export declare type IUniversitiesData = RootData<graphqlNormalize & IUniversity[], 'universities'>;

package/dist/cjs/resolvers/query/user.d.ts

@@ -0,0 +1,13 @@
+import { RootData } from '../types';
+export interface IUsernameAvailableVar {
+    username: string;
+}
+export declare type IUsernameAvailableData = RootData<boolean, 'usernameAvailable'>;
+export interface IUsernameProvisionedVar {
+    username: string;
+}
+export declare type IUsernameProvisionedData = RootData<boolean, 'usernameProvisioned'>;
+export interface IValidateResetPasswordTokenVar {
+    token: string;
+}
+export declare type IValidateResetPasswordTokenData = RootData<string, 'validateResetPasswordToken'>;

package/dist/cjs/resolvers/query/video.d.ts

@@ -0,0 +1,15 @@
+import { Id, IVideo } from '../../models';
+import { graphqlNormalize, RootData } from '../types';
+export interface IVideosVar {
+    filter: 'new' | 'popular' | 'personal' | 'live';
+    limit: number;
+}
+export declare type IVideosData = RootData<(graphqlNormalize & IVideo)[], 'videos'>;
+export interface IVideoVar {
+    id: Id;
+}
+export declare type IVideoData = RootData<graphqlNormalize & IVideo, 'video'>;
+export interface IZoomSignatureVar {
+    meetingNumber: string;
+}
+export declare type IZoomSignatureData = RootData<graphqlNormalize & string, 'zoomSignature'>;

package/dist/cjs/resolvers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types.d.ts

@@ -0,0 +1 @@
+declare module 'fmt-obj';

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

@@ -35,7 +35,27 @@ function mapPrescribeMarkToAnswer(obj) {
 }
 exports.mapPrescribeMarkToAnswer = mapPrescribeMarkToAnswer;
 function formatPrescribeAnswer(baseAnswer) {
-    const obj = Object.assign(Object.assign({}, baseAnswer), { drug: Object.assign({}, baseAnswer.drug), dose: Object.assign({}, baseAnswer.dose), units: Object.assign({}, baseAnswer.units), route: Object.assign({}, baseAnswer.route), frequency: Object.assign({}, baseAnswer.frequency), duration: Object.assign({}, baseAnswer.duration) });
+    const obj = {
+        ...baseAnswer,
+        drug: {
+            ...baseAnswer.drug,
+        },
+        dose: {
+            ...baseAnswer.dose,
+        },
+        units: {
+            ...baseAnswer.units,
+        },
+        route: {
+            ...baseAnswer.route,
+        },
+        frequency: {
+            ...baseAnswer.frequency,
+        },
+        duration: {
+            ...baseAnswer.duration,
+        },
+    };
     obj.drug.value = obj.drug.value.toLowerCase().replace(/\s/g, '');
     obj.route.value = obj.route.value
         .toLowerCase()

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;
+}