@quesmed/types 1.5.7 → 1.6.1

package/utils/offlineLink.mjs

@@ -1,230 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { ApolloLink, Observable, } from '@apollo/client';
-import uuid from './uuid4';
-export class OfflineLink extends 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 Observable((observer) => {
-            const mutationId = uuid.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.
-     */
-    getQueue() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const map = new Map();
-            try {
-                const storedMutations = yield this.storage.getItem(this.prefix + 'Mutations');
-                if (!storedMutations) {
-                    return map;
-                }
-                const mutationIds = storedMutations.split(',');
-                for (const mutationId of mutationIds) {
-                    const storedMutation = yield 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.
-     */
-    saveQueue(mutationId, mutation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (mutationId && mutation) {
-                    yield this.storage.setItem(this.prefix + mutationId, JSON.stringify(mutation));
-                }
-                yield 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.
-     */
-    add(item, mutationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // We give the mutation attempt a random id so that it is easy to remove when needed (in sync loop)
-            if (!mutationId) {
-                mutationId = uuid.asBase64();
-            }
-            this.queue.set(mutationId, item);
-            yield this.saveQueue(mutationId, item);
-            return mutationId;
-        });
-    }
-    /**
-     * Remove a mutation attempt from the queue.
-     */
-    remove(mutationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.queue.delete(mutationId);
-            yield this.storage.removeItem(this.prefix + mutationId);
-            yield this.saveQueue();
-        });
-    }
-    /**
-     * Takes the mutations in the queue and try to send them to the server again.
-     */
-    sync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 {
-                        yield this.client.mutate(Object.assign(Object.assign({}, attempt), { optimisticResponse: undefined }));
-                        serverProcessed = true;
-                    }
-                    catch (e) {
-                        const err = e;
-                        const networkError = err.networkError;
-                        if (!this.retryOnServerError && (networkError === null || networkError === void 0 ? void 0 : 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 {
-                            yield this.remove(mutationId);
-                        }
-                        catch (e) {
-                            console.error(e);
-                        }
-                    }
-                }
-            }
-            else {
-                yield Promise.all(attempts.map(([mutationId, attempt]) => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    let serverProcessed = false;
-                    try {
-                        yield ((_a = this.client) === null || _a === void 0 ? void 0 : _a.mutate(Object.assign(Object.assign({}, attempt), { optimisticResponse: undefined })));
-                        serverProcessed = true;
-                    }
-                    catch (e) {
-                        const err = e;
-                        const networkError = err.networkError;
-                        if (!this.retryOnServerError && (networkError === null || networkError === void 0 ? void 0 : networkError.response)) {
-                            serverProcessed = true;
-                        }
-                    }
-                    if (serverProcessed) {
-                        yield this.remove(mutationId);
-                    }
-                })));
-            }
-            // Remaining mutations in the queue are persisted
-            yield 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).
-     */
-    setup(client) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.client = client;
-            this.queue = yield this.getQueue();
-            yield this.sync();
-        });
-    }
-}