How to use the relay-runtime.Observable.create function in relay-runtime

.mergeMap(payload =>
          Observable.create(sink => {
            onNext(payload, () => {
              sink.next(); // pass void to public observer's `next`
              sink.complete();
            });
          }),
        )

.mergeMap(payload =>
          Observable.create(sink => {
            onNext(payload, () => {
              sink.next(); // pass void to public observer's `next`
              sink.complete();
            });
          }),
        )

return RelayObservable.create((sink) => {
        const { operation, optimisticResponse, optimisticUpdater, updater, uploadables } = mutationOptions;
        let optimisticConfig;
        if (optimisticResponse || optimisticUpdater) {
            optimisticConfig = {
                operation,
                response: optimisticResponse,
                updater: optimisticUpdater,
            };
        }
        const store = environment.getStore();
        const originalPublish = store.publish;
        let backup;
        let sinkPublish;

        const source = RelayObservable.create((sink) => {
            store.publish = function(source): void {
                sinkPublish = source;
                store.publish = originalPublish;
                store.publish(source);
            };
            resolveImmediate(() => {
                // come recuperare i dati che sono stati inseriti? override del publish? dello store?
                backup = environment.getStore().getSource()._sink;
                sink.next({
                    data: optimisticResponse ? optimisticResponse : {},
                });
                store.publish = originalPublish;

                const id = uuid();
                const payload: Payload = {
                    operation,

let _pendingQueries = pendingQueriesByEnvironment.get(environment);
  if (_pendingQueries == null) {
    _pendingQueries = new Map();
    pendingQueriesByEnvironment.set(environment, _pendingQueries);
  }
  const pendingQueries: Map = _pendingQueries; // store in a const for flow
  const queryEntry = preloadQueryDeduped(
    environment,
    pendingQueries,
    preloadableRequest,
    variables,
    options,
  );
  const source =
    queryEntry.kind === 'network'
      ? Observable.create(sink => {
          const subscription = queryEntry.subject.subscribe(sink);
          return () => {
            subscription.unsubscribe();
            cleanup(pendingQueries, queryEntry);
          };
        })
      : null;
  return {
    environment,
    environmentProviderOptions,
    fetchKey: queryEntry.fetchKey,
    fetchPolicy: queryEntry.fetchPolicy,
    name: queryEntry.name,
    source,
    variables,
  };

.mergeMap(response => {
          this.state.resolver.setVariables(
            fragmentVariables,
            operation.request.node,
          );
          return Observable.create(sink =>
            this.setState(
              latestState => ({
                data: latestState.resolver.resolve(),
                contextForChildren: {
                  environment: this.props.__relayContext.environment,
                },
              }),
              () => {
                sink.next();
                sink.complete();
              },
            ),
          );
        })
        .finally(() => {

publish(environment, mutationOptions) {
        return RelayObservable.create(sink => {
            const {
                operation,
                optimisticResponse,
                optimisticUpdater,
                updater,
                uploadables,
            } = mutationOptions;


            const backup = new RelayInMemoryRecordSource();
            let sinkPublish = new RelayInMemoryRecordSource()
            if (optimisticResponse || optimisticUpdater) {
                const sink = new RelayInMemoryRecordSource();
                const mutator = new RelayRecordSourceMutator(
                    environment.getStore().getSource(),
                    sink,

_loadMore: function _loadMore(pageSize, observerOrCallback, options) {
        if (!this._canFetchPage('loadMore')) {
          return {
            dispose: function dispose() {}
          };
        }

        var observer = toObserver(observerOrCallback);

        var connectionData = this._getConnectionData();

        if (!connectionData) {
          Observable.create(function (sink) {
            return sink.complete();
          }).subscribe(observer);
          return null;
        }

        var totalCount = connectionData.edgeCount + pageSize;

        if (options && options.force) {
          return this._refetchConnection(totalCount, observerOrCallback);
        }

        var _ConnectionInterface$2 = ConnectionInterface.get(),
            END_CURSOR = _ConnectionInterface$2.END_CURSOR,
            START_CURSOR = _ConnectionInterface$2.START_CURSOR;

        var cursor = connectionData.cursor;

_loadMore = (
      pageSize: number,
      observerOrCallback: ?ObserverOrCallback,
      options: ?RefetchOptions,
    ): ?Disposable => {
      if (!this._canFetchPage('loadMore')) {
        return {
          dispose() {},
        };
      }

      const observer = toObserver(observerOrCallback);
      const connectionData = this._getConnectionData();
      if (!connectionData) {
        Observable.create(sink => sink.complete()).subscribe(observer);
        return null;
      }
      const totalCount = connectionData.edgeCount + pageSize;
      if (options && options.force) {
        return this._refetchConnection(totalCount, observerOrCallback);
      }
      const {END_CURSOR, START_CURSOR} = ConnectionInterface.get();
      const cursor = connectionData.cursor;
      warning(
        cursor != null && cursor !== '',
        'ReactRelayPaginationContainer: Cannot `loadMore` without valid `%s` (got `%s`)',
        direction === FORWARD ? END_CURSOR : START_CURSOR,
        cursor,
      );
      const paginatingVariables = {
        count: pageSize,

public executeMutation(mutationOptions): RelayObservable {
        if (this.isOnline()) {
            return super.executeMutation(mutationOptions);
        } else {
            return RelayObservable.create((sink) => {
                this._relayStoreOffline.publish(this, mutationOptions).subscribe({
                    complete: () => sink.complete(),
                    error: (error) => sink.error(error),
                    next: (response) => sink.next(response),
                });
                return (): any => {};
            });
        }
    }
}

const fetchQuery = (operation, variables): Promise => {
    return Observable.create(observer => {
      if (operation.operationKind !== 'mutation') {
        asyncStoreRead(observer, operation, variables);
      }
      if (ConnectionManager.isConnected()) {
        fetchFromTheNetwork(networkHeaders, operation, variables, observer);
      }
    });
  };