apollo-client - npm Package Compare versions

Comparing version 0.3.30 to 0.4.0

actions.d.ts

@@ -61,2 +61,9 @@ import { GraphQLResult } from 'graphql';
 export declare function isMutationResultAction(action: ApolloAction): action is MutationResultAction;
+export interface MutationErrorAction {
+    type: 'APOLLO_MUTATION_ERROR';
+    error: Error;
+    mutationId: string;
+    resultBehaviors?: MutationBehavior[];
+}
+export declare function isMutationErrorAction(action: ApolloAction): action is MutationErrorAction;
 export interface StoreResetAction {
@@ -67,2 +74,2 @@ type: 'APOLLO_STORE_RESET';
 export declare function isStoreResetAction(action: ApolloAction): action is StoreResetAction;
-export declare type ApolloAction = QueryResultAction | QueryErrorAction | QueryInitAction | QueryResultClientAction | QueryStopAction | MutationInitAction | MutationResultAction | StoreResetAction;
+export declare type ApolloAction = QueryResultAction | QueryErrorAction | QueryInitAction | QueryResultClientAction | QueryStopAction | MutationInitAction | MutationResultAction | MutationErrorAction | StoreResetAction;

actions.js

@@ -30,2 +30,7 @@ "use strict";
 exports.isMutationResultAction = isMutationResultAction;
+;
+function isMutationErrorAction(action) {
+    return action.type === 'APOLLO_MUTATION_ERROR';
+}
+exports.isMutationErrorAction = isMutationErrorAction;
 function isStoreResetAction(action) {
@@ -32,0 +37,0 @@ return action.type === 'APOLLO_STORE_RESET';

index.d.ts

 import { NetworkInterface, createNetworkInterface, addQueryMerging } from './networkInterface';
-import { GraphQLResult, Document, FragmentDefinition } from 'graphql';
+import { Document, FragmentDefinition } from 'graphql';
 import { print } from 'graphql-tag/printer';
@@ -12,2 +12,5 @@ import { createApolloStore, ApolloStore, createApolloReducer, ApolloReducerConfig } from './store';
 export { createNetworkInterface, addQueryMerging, createApolloStore, createApolloReducer, readQueryFromStore, readFragmentFromStore, addTypenameToSelectionSet as addTypename, writeQueryToStore, writeFragmentToStore, print as printAST };
+export declare type ApolloQueryResult = {
+    data: any;
+};
 export declare let fragmentDefinitionsMap: {
@@ -44,3 +47,5 @@ [fragmentName: string]: FragmentDefinition[];
     watchQuery: (options: WatchQueryOptions) => ObservableQuery;
-    query: (options: WatchQueryOptions) => Promise<GraphQLResult>;
+    query: (options: WatchQueryOptions) => Promise<{
+        data: any;
+    }>;
     mutate: (options: {
@@ -63,3 +68,5 @@ mutation: Document;
         fragments?: FragmentDefinition[];
-    }) => Promise<GraphQLResult>;
+    }) => Promise<{
+        data: any;
+    }>;
     reducer(): Function;
@@ -66,0 +73,0 @@ middleware: () => (store: ApolloStore) => (next: any) => (action: any) => any;

mutations/store.js

@@ -26,2 +26,9 @@ "use strict";
     }
+    else if (actions_1.isMutationErrorAction(action)) {
+        var newState = assign({}, previousState);
+        newState[action.mutationId] = assign({}, previousState[action.mutationId], {
+            loading: false,
+            error: action.error,
+        });
+    }
     else if (actions_1.isStoreResetAction(action)) {
@@ -28,0 +35,0 @@ return {};

package.json

 {
   "name": "apollo-client",
-  "version": "0.3.30",
+  "version": "0.4.0",
   "description": "A simple yet functional GraphQL client.",
@@ -5,0 +5,0 @@ "main": "index.js",

QueryManager.d.ts

@@ -5,14 +5,19 @@ import { NetworkInterface } from './networkInterface';
 import { QueryTransformer } from './queries/queryTransform';
-import { GraphQLResult, Document, FragmentDefinition } from 'graphql';
+import { Document, FragmentDefinition } from 'graphql';
 import { MutationBehavior } from './data/mutationResults';
-import { Observable, Observer, Subscription } from './util/Observable';
-export declare class ObservableQuery extends Observable<GraphQLResult> {
-    subscribe(observer: Observer<GraphQLResult>): QuerySubscription;
-    result(): Promise<GraphQLResult>;
+import { ApolloQueryResult } from './index';
+import { Observable, Observer, Subscription, SubscriberFunction } from './util/Observable';
+export declare class ObservableQuery extends Observable<ApolloQueryResult> {
+    refetch: (variables?: any) => Promise<ApolloQueryResult>;
+    stopPolling: () => void;
+    startPolling: (p: number) => void;
+    constructor(options: {
+        subscriberFunction: SubscriberFunction<ApolloQueryResult>;
+        refetch: (variables?: any) => Promise<ApolloQueryResult>;
+        stopPolling: () => void;
+        startPolling: (p: number) => void;
+    });
+    subscribe(observer: Observer<ApolloQueryResult>): Subscription;
+    result(): Promise<ApolloQueryResult>;
 }
-export interface QuerySubscription extends Subscription {
-    refetch(variables?: any): Promise<GraphQLResult>;
-    stopPolling(): void;
-    startPolling(pollInterval: number): void;
-}
 export interface WatchQueryOptions {
@@ -55,7 +60,7 @@ query: Document;
         fragments?: FragmentDefinition[];
-    }): Promise<GraphQLResult>;
-    queryListenerForObserver(options: WatchQueryOptions, observer: Observer<GraphQLResult>): QueryListener;
+    }): Promise<ApolloQueryResult>;
+    queryListenerForObserver(options: WatchQueryOptions, observer: Observer<ApolloQueryResult>): QueryListener;
     watchQuery(options: WatchQueryOptions, shouldSubscribe?: boolean): ObservableQuery;
-    query(options: WatchQueryOptions): Promise<GraphQLResult>;
-    fetchQuery(queryId: string, options: WatchQueryOptions): Promise<GraphQLResult>;
+    query(options: WatchQueryOptions): Promise<ApolloQueryResult>;
+    fetchQuery(queryId: string, options: WatchQueryOptions): Promise<ApolloQueryResult>;
     generateQueryId(): string;
@@ -66,6 +71,6 @@ stopQueryInStore(queryId: string): void;
     removeQueryListener(queryId: string): void;
-    addFetchQueryPromise(requestId: number, promise: Promise<GraphQLResult>, resolve: (result: GraphQLResult) => void, reject: (error: Error) => void): void;
+    addFetchQueryPromise(requestId: number, promise: Promise<ApolloQueryResult>, resolve: (result: ApolloQueryResult) => void, reject: (error: Error) => void): void;
     removeFetchQueryPromise(requestId: number): void;
     addObservableQuery(queryId: string, observableQuery: ObservableQuery): void;
-    addQuerySubscription(queryId: string, querySubscription: QuerySubscription): void;
+    addQuerySubscription(queryId: string, querySubscription: Subscription): void;
     removeObservableQuery(queryId: string): void;
@@ -72,0 +77,0 @@ resetStore(): void;

QueryManager.js

@@ -19,6 +19,10 @@ "use strict";
 var Observable_1 = require('./util/Observable');
+var errors_1 = require('./errors');
 var ObservableQuery = (function (_super) {
     __extends(ObservableQuery, _super);
-    function ObservableQuery() {
-        _super.apply(this, arguments);
+    function ObservableQuery(options) {
+        _super.call(this, options.subscriberFunction);
+        this.refetch = options.refetch;
+        this.stopPolling = options.stopPolling;
+        this.startPolling = options.startPolling;
     }
@@ -124,2 +128,11 @@ ObservableQuery.prototype.subscribe = function (observer) {
             return result;
+        })
+            .catch(function (err) {
+            _this.store.dispatch({
+                type: 'APOLLO_MUTATION_ERROR',
+                error: err,
+                mutationId: mutationId,
+                resultBehaviors: resultBehaviors,
+            });
+            return Promise.reject(err);
         });
@@ -130,14 +143,16 @@ };
         return function (queryStoreValue) {
+            if (!queryStoreValue) {
+                return;
+            }
             if (!queryStoreValue.loading || queryStoreValue.returnPartialData) {
-                if (queryStoreValue.graphQLErrors) {
-                    if (observer.next) {
-                        observer.next({ errors: queryStoreValue.graphQLErrors });
-                    }
-                }
-                else if (queryStoreValue.networkError) {
+                if (queryStoreValue.graphQLErrors || queryStoreValue.networkError) {
+                    var apolloError = new errors_1.ApolloError({
+                        graphQLErrors: queryStoreValue.graphQLErrors,
+                        networkError: queryStoreValue.networkError,
+                    });
                     if (observer.error) {
-                        observer.error(queryStoreValue.networkError);
+                        observer.error(apolloError);
                     }
                     else {
-                        console.error('Unhandled network error', queryStoreValue.networkError, queryStoreValue.networkError.stack);
+                        console.error('Unhandled error', apolloError, apolloError.stack);
                     }
@@ -165,4 +180,5 @@ }
         getFromAST_1.getQueryDefinition(options.query);
-        var observableQuery = new ObservableQuery(function (observer) {
-            var queryId = _this.generateQueryId();
+        var queryId = this.generateQueryId();
+        var observableQuery;
+        var subscriberFunction = function (observer) {
             var retQuerySubscription = {
@@ -172,21 +188,2 @@ unsubscribe: function () {
                 },
-                refetch: function (variables) {
-                    variables = variables || options.variables;
-                    return _this.fetchQuery(queryId, assign(options, {
-                        forceFetch: true,
-                        variables: variables,
-                    }));
-                },
-                stopPolling: function () {
-                    if (_this.pollingTimers[queryId]) {
-                        clearInterval(_this.pollingTimers[queryId]);
-                    }
-                },
-                startPolling: function (pollInterval) {
-                    _this.pollingTimers[queryId] = setInterval(function () {
-                        var pollingOptions = assign({}, options);
-                        pollingOptions.forceFetch = true;
-                        _this.fetchQuery(queryId, pollingOptions);
-                    }, pollInterval);
-                },
             };
@@ -197,36 +194,29 @@ if (shouldSubscribe) {
             }
-            _this.startQuery(queryId, options, function (queryStoreValue) {
-                if (!queryStoreValue) {
-                    return;
-                }
-                if (!queryStoreValue.loading || queryStoreValue.returnPartialData) {
-                    if (queryStoreValue.graphQLErrors) {
-                        if (observer.next) {
-                            observer.next({ errors: queryStoreValue.graphQLErrors });
-                        }
-                    }
-                    else if (queryStoreValue.networkError) {
-                        if (observer.error) {
-                            observer.error(queryStoreValue.networkError);
-                        }
-                        else {
-                            console.error('Unhandled network error', queryStoreValue.networkError, queryStoreValue.networkError.stack);
-                        }
-                    }
-                    else {
-                        var resultFromStore = readFromStore_1.readSelectionSetFromStore({
-                            store: _this.getApolloState().data,
-                            rootId: queryStoreValue.query.id,
-                            selectionSet: queryStoreValue.query.selectionSet,
-                            variables: queryStoreValue.variables,
-                            returnPartialData: options.returnPartialData,
-                            fragmentMap: queryStoreValue.fragmentMap,
-                        });
-                        if (observer.next) {
-                            observer.next({ data: resultFromStore });
-                        }
-                    }
-                }
-            });
+            _this.startQuery(queryId, options, _this.queryListenerForObserver(options, observer));
             return retQuerySubscription;
+        };
+        var refetch = function (variables) {
+            variables = variables || options.variables;
+            return _this.fetchQuery(queryId, assign(options, {
+                forceFetch: true,
+                variables: variables,
+            }));
+        };
+        var stopPolling = function () {
+            if (_this.pollingTimers[queryId]) {
+                clearInterval(_this.pollingTimers[queryId]);
+            }
+        };
+        var startPolling = function (pollInterval) {
+            _this.pollingTimers[queryId] = setInterval(function () {
+                var pollingOptions = assign({}, options);
+                pollingOptions.forceFetch = true;
+                _this.fetchQuery(queryId, pollingOptions);
+            }, pollInterval);
+        };
+        observableQuery = new ObservableQuery({
+            subscriberFunction: subscriberFunction,
+            refetch: refetch,
+            stopPolling: stopPolling,
+            startPolling: startPolling,
         });
@@ -315,4 +305,3 @@ return observableQuery;
         Object.keys(this.observableQueries).forEach(function (queryId) {
-            var subscriptions = _this.observableQueries[queryId].subscriptions;
-            subscriptions[subscriptions.length - 1].refetch();
+            _this.observableQueries[queryId].observableQuery.refetch();
         });
@@ -420,2 +409,7 @@ };
                     _this.removeFetchQueryPromise(requestId);
+                    if (result.errors) {
+                        reject(new errors_1.ApolloError({
+                            graphQLErrors: result.errors,
+                        }));
+                    }
                     return result;
@@ -445,3 +439,5 @@ }).then(function () {
                     _this.removeFetchQueryPromise(requestId);
-                    return error;
+                    reject(new errors_1.ApolloError({
+                        networkError: error,
+                    }));
                 });
@@ -448,0 +444,0 @@ });

scheduler.js

@@ -31,4 +31,4 @@ "use strict";
             queryId = this.queryManager.generateQueryId();
-            this.fetchQuery(queryId, options);
         }
+        this.fetchQuery(queryId, options);
         this.queryManager.addQueryListener(queryId, listener);
@@ -56,5 +56,6 @@ this.pollingTimers[queryId] = setInterval(function () {
         }
-        return new QueryManager_1.ObservableQuery(function (observer) {
+        var queryId = this.queryManager.generateQueryId();
+        var subscriberFunction = function (observer) {
             var queryListener = _this.queryManager.queryListenerForObserver(options, observer);
-            var queryId = _this.startPollingQuery(options, queryListener);
+            _this.startPollingQuery(options, queryListener, queryId);
             return {
@@ -64,22 +65,28 @@ unsubscribe: function () {
                 },
-                refetch: function (variables) {
-                    variables = variables || options.variables;
-                    return _this.fetchQuery(queryId, assign(options, {
-                        forceFetch: true,
-                        variables: variables,
-                    }));
-                },
-                startPolling: function (pollInterval) {
-                    _this.pollingTimers[queryId] = setInterval(function () {
-                        var pollingOptions = assign({}, options);
-                        pollingOptions.forceFetch = true;
-                        _this.fetchQuery(queryId, pollingOptions).then(function () {
-                            _this.removeInFlight(queryId);
-                        });
-                    }, pollInterval);
-                },
-                stopPolling: function () {
-                    _this.stopPollingQuery(queryId);
-                },
             };
+        };
+        var refetch = function (variables) {
+            variables = variables || options.variables;
+            return _this.fetchQuery(queryId, assign(options, {
+                forceFetch: true,
+                variables: variables,
+            }));
+        };
+        var startPolling = function () {
+            _this.pollingTimers[queryId] = setInterval(function () {
+                var pollingOptions = assign({}, options);
+                pollingOptions.forceFetch = true;
+                _this.fetchQuery(queryId, pollingOptions).then(function () {
+                    _this.removeInFlight(queryId);
+                });
+            }, options.pollInterval);
+        };
+        var stopPolling = function () {
+            _this.stopPollingQuery(queryId);
+        };
+        return new QueryManager_1.ObservableQuery({
+            subscriberFunction: subscriberFunction,
+            refetch: refetch,
+            stopPolling: stopPolling,
+            startPolling: startPolling,
         });
@@ -86,0 +93,0 @@ };

Fixed alerts

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

213219

1.43%

Number of package files

79

2.6%

Lines of code

3166

2.23%

Number of low supply chain risk alerts

0

-100%

No dependency changes