Using memoizee with observables

memoize-decorator.ts

import { decorate } from 'core-decorators';
import * as memoize from 'memoizee';
import { duration, unitOfTime } from 'moment';
import { memoizeObservable } from './rxjs';

type HumanDuration = [number, unitOfTime.DurationConstructor];

export interface MemoizeOptions extends memoize.Options {
    observable?: boolean;
    ttl?: HumanDuration;
}

export function Memoize(options: MemoizeOptions) {
    const wrapperFunction = options.observable ?
        memoizeObservable : memoize;
    if (options.ttl) {
        options = {
            ...options,
            maxAge: duration(...options.ttl).asMilliseconds(),
        };
    }
    return decorate.call(this, wrapperFunction, options);
}

memoizee-observable.ts

import * as memoizee from 'memoizee';
import { pipe, Subject } from 'rxjs';
import { share, takeUntil } from 'rxjs/operators';

type ObservableFunction = <T>(args: any[]) => Observable<T>;
export function memoizeObservable(toWrap: ObservableFunction, options: memoizee.Options) {
    const disposeSymbol = Symbol('___dispose');
    const newOptions: memoizee.Options = Object.assign({
        normalizer: (args: any[]) => {
            // not sure why this is needed? without it all arguments yield the same cached value
            return Array.from(args);
        },
    }, options, {
        dispose(value: any) {
            value[disposeSymbol]();
        },
    });

    return memoizee(function() {
        const result$ = toWrap.apply(this, arguments);
        const expired$ = new Subject();
        const sharedResult$ = result$.pipe(takeUntil(expired$), shareReplay(1));
        (sharedResult$ as any)[disposeSymbol] = () => expired$.next();
        return sharedResult$;
    }, newOptions);
}