@schemeless/event-store-react-native/dist/makeEventStore.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.makeEventStore = void 0;
const Rx = require("rxjs/operators");
const event_store_types_1 = require("@schemeless/event-store-types");
const makeMainQueue_1 = require("./queue/makeMainQueue");
const makeReceive_1 = require("./queue/makeReceive");
const makeReplay_1 = require("./makeReplay");
const makeSideEffectQueue_1 = require("./queue/makeSideEffectQueue");
const rxjs_1 = require("rxjs");
const makeEventStore = (eventStoreRepo) => (eventFlows, successEventObservers = []) => __awaiter(void 0, void 0, void 0, function* () {
    const mainQueue = (0, makeMainQueue_1.makeMainQueue)(eventFlows);
    const sideEffectQueue = (0, makeSideEffectQueue_1.makeSideEffectQueue)(eventFlows, mainQueue);
    yield eventStoreRepo.init();
    const mainQueueProcessed$ = mainQueue.processed$.pipe(Rx.concatMap(([doneEvents, eventTaskAndError]) => __awaiter(void 0, void 0, void 0, function* () {
        if (!eventTaskAndError) {
            yield eventStoreRepo.storeEvents(doneEvents);
            doneEvents.forEach((event) => sideEffectQueue.push({ event, retryCount: 0 }));
            return [doneEvents, eventTaskAndError];
        }
        else {
            // todo store failed event
            return [doneEvents, eventTaskAndError];
        }
    })), Rx.mergeMap(([doneEvents, eventTaskAndError]) => {
        if (!eventTaskAndError) {
            return (0, rxjs_1.from)(doneEvents.map((e) => ({
                event: e,
                state: event_store_types_1.EventOutputState.success,
            })));
        }
        else {
            return (0, rxjs_1.from)([{ event: eventTaskAndError.task, state: event_store_types_1.EventOutputState.invalid, error: eventTaskAndError.error }].concat(doneEvents.map((e) => ({ event: e, state: event_store_types_1.EventOutputState.canceled, error: undefined }))));
        }
    }));
    const doneAndSideEffect$ = (0, rxjs_1.merge)(mainQueueProcessed$, sideEffectQueue.processed$).pipe(Rx.share());
    // const { result$, observerQueue } = assignObserver(doneAndSideEffect$, successEventObservers);
    const output$ = doneAndSideEffect$;
    // Ensure queues start draining even if callers only subscribe later.
    output$.subscribe(() => undefined);
    return {
        mainQueue,
        sideEffectQueue,
        receive: (0, makeReceive_1.makeReceive)(mainQueue, successEventObservers),
        replay: (0, makeReplay_1.makeReplay)(eventFlows, successEventObservers, eventStoreRepo),
        eventStoreRepo: eventStoreRepo,
        output$,
    };
});
exports.makeEventStore = makeEventStore;