@schemeless/event-store-react-native/dist/queue/makeSideEffectQueue.js

React Native compatible build of the [`@schemeless/event-store`](../event-store) runtime. It mirrors the Node.js implementation but swaps the internal queue implementation to [`react-native-better-queue`](https://github.com/YahyaASadiq/react-native-better

"use strict";
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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.makeSideEffectQueue = void 0;
const event_store_types_1 = require("@schemeless/event-store-types");
const RxQueue_1 = require("./RxQueue");
const registerEventFlowTypes_1 = require("../operators/registerEventFlowTypes");
const Rx = require("rxjs/operators");
const logEvent_1 = require("../util/logEvent");
const getEventFlow_1 = require("../operators/getEventFlow");
const logger_1 = require("../util/logger");
const makeSideEffectQueue = (eventFlows, mainQueue) => {
    const sideEffectQueue = (0, RxQueue_1.createRxQueue)('sideEffect', {
        concurrent: 1,
    });
    const eventFlowMap = (0, registerEventFlowTypes_1.registerEventFlowTypes)({}, eventFlows);
    const processed$ = sideEffectQueue.process$.pipe(Rx.mergeMap(({ task: { retryCount, event }, done }) => __awaiter(void 0, void 0, void 0, function* () {
        var _a;
        const eventFlow = (0, getEventFlow_1.getEventFlow)(eventFlowMap)(event);
        if (!eventFlow.sideEffect) {
            (0, logEvent_1.logEvent)(event, '🌠', 'SideEffect:N/A');
            done();
            return { event, state: event_store_types_1.SideEffectsState.done };
        }
        else {
            try {
                const nextEvents = (yield eventFlow.sideEffect(event));
                (0, logEvent_1.logEvent)(event, '🌠', 'SideEffect:Done');
                if (nextEvents === null || nextEvents === void 0 ? void 0 : nextEvents.length) {
                    nextEvents.forEach((nextEvent) => {
                        mainQueue.push(nextEvent);
                    });
                }
                done();
                return { event, state: event_store_types_1.SideEffectsState.done };
            }
            catch (error) {
                logger_1.logger.error(error.toString());
                const sideEffectFailedRetryAllowed = (_a = eventFlow.meta) === null || _a === void 0 ? void 0 : _a.sideEffectFailedRetryAllowed;
                if (sideEffectFailedRetryAllowed && retryCount < sideEffectFailedRetryAllowed) {
                    (0, logEvent_1.logEvent)(event, '🌠', 'SE:Retry:' + retryCount);
                    sideEffectQueue.push({ retryCount: retryCount + 1, event });
                    done();
                    return { event, state: event_store_types_1.SideEffectsState.retry };
                }
                else {
                    (0, logEvent_1.logEvent)(event, '🌠', 'SE:FAILED:' + retryCount);
                    done();
                    return { event, state: event_store_types_1.SideEffectsState.fail };
                }
            }
        }
    })));
    return {
        processed$,
        queueInstance: sideEffectQueue,
        push: sideEffectQueue.push.bind(sideEffectQueue),
    };
};
exports.makeSideEffectQueue = makeSideEffectQueue;