Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
.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);
}
});
};