cloudrx/dist/src/operators/persist.js

TypeScript library for streaming cloud provider events using RxJS with automatic persistence and replay capabilities

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.persistReplay = exports.persist = void 0;
const rxjs_1 = require("rxjs");
const persist = (provider) => {
    return (source) => {
        return new rxjs_1.Observable((subscriber) => {
            const state = {
                buffer: [],
                ready: false,
                complete: false,
                provider: undefined,
            };
            const storeValue = (value) => {
                if (!state.provider) {
                    return (0, rxjs_1.of)(value).pipe((0, rxjs_1.delay)(1000));
                }
                return state.provider.store(value);
            };
            const checkCompletion = () => {
                if (state.complete && state.buffer.length === 0) {
                    subscriber.complete();
                }
            };
            const processBufferedValues = () => {
                if (state.buffer.length === 0) {
                    checkCompletion();
                    return;
                }
                const valuesToProcess = [...state.buffer];
                state.buffer = [];
                processValuesSequentially(valuesToProcess);
            };
            const processValuesSequentially = (values) => {
                if (values.length === 0) {
                    checkCompletion();
                    return;
                }
                const [currentValue, ...remainingValues] = values;
                if (currentValue === undefined) {
                    processValuesSequentially(remainingValues);
                    return;
                }
                storeValue(currentValue).subscribe({
                    next: (data) => subscriber.next(data),
                    error: (error) => subscriber.error(error),
                    complete: () => processValuesSequentially(remainingValues),
                });
            };
            const handleProviderReady = (provider) => {
                state.provider = provider;
                state.ready = true;
                processBufferedValues();
            };
            const handleSourceValue = (value) => {
                if (state.ready) {
                    storeValue(value).subscribe({
                        next: (data) => subscriber.next(data),
                        error: (error) => subscriber.error(error),
                    });
                }
                else {
                    state.buffer.push(value);
                }
            };
            const handleSourceComplete = () => {
                state.complete = true;
                if (state.ready && state.buffer.length === 0) {
                    subscriber.complete();
                }
            };
            const providerSub = provider
                ? provider.pipe((0, rxjs_1.first)()).subscribe({
                    next: handleProviderReady,
                    error: (error) => subscriber.error(error),
                })
                : (handleProviderReady(undefined), undefined);
            const sourceSub = source.subscribe({
                next: handleSourceValue,
                error: (error) => subscriber.error(error),
                complete: handleSourceComplete,
            });
            return () => {
                providerSub?.unsubscribe();
                sourceSub.unsubscribe();
            };
        });
    };
};
exports.persist = persist;
const persistReplay = (provider) => {
    return (source) => {
        return new rxjs_1.Observable((subscriber) => {
            const persistSub = source.pipe((0, exports.persist)(provider)).subscribe(subscriber);
            const replaySub = provider
                ?.pipe((0, rxjs_1.switchMap)((p) => p.all().pipe((0, rxjs_1.map)((event) => {
                const unmarshalled = p.unmarshall(event);
                delete unmarshalled.__marker__;
                return unmarshalled;
            }))))
                .subscribe(subscriber);
            return () => {
                persistSub.unsubscribe();
                replaySub?.unsubscribe();
            };
        });
    };
};
exports.persistReplay = persistReplay;
//# sourceMappingURL=persist.js.map