@kubun/with-apollo 0.17.2 → 0.18.0

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 import { ApolloLink } from '@apollo/client';
+import { type SubscriptionRecoveryOptions } from '@kubun/client';
 import type { GraphQLSource } from '@kubun/protocol';
 /**
  * The connector operation-envelope ids a mutation carries (see
@@ -15,4 +16,11 @@ export type OperationEnvelope = {
  * link, for a mutation (`client.mutate({ context })` / `useMutation`).
  */
 export declare function operationEnvelopeContext(envelope: OperationEnvelope): Record<string, unknown>;
-export declare function createLink(source: GraphQLSource): ApolloLink;
+export type LinkOptions = SubscriptionRecoveryOptions & {
+    /**
+     * Makes the client's data consistent again after a subscription recovered: events sent
+     * while it was down are lost. Defaults to refetching the client's active queries.
+     */
+    rebaseline?: (operation: ApolloLink.Operation) => Promise<unknown>;
+};
+export declare function createLink(source: GraphQLSource, options?: LinkOptions): ApolloLink;

package/lib/index.js

@@ -1,5 +1,6 @@
 import { ApolloLink, Observable } from '@apollo/client';
 import { getMainDefinition, print } from '@apollo/client/utilities';
+import { runRecoveringSubscription } from '@kubun/client';
 const OPERATION_ENVELOPE_KEY = 'kubunOperationEnvelope';
 /**
  * The Apollo operation `context` that carries an operation envelope to the
@@ -46,7 +47,12 @@ function observableWithError(error) {
         subscriber.error(error);
     });
 }
-export function createLink(source) {
+function refetchActiveQueries(operation) {
+    return Promise.resolve(operation.client.refetchQueries({
+        include: 'active'
+    }));
+}
+export function createLink(source, options = {}) {
     return new ApolloLink((operation)=>{
         const definition = getMainDefinition(operation.query);
         if (definition.kind !== 'OperationDefinition') {
@@ -57,47 +63,21 @@ export function createLink(source) {
             variables: operation.variables
         };
         if (definition.operation === 'subscription') {
+            const rebaseline = options.rebaseline ?? refetchActiveQueries;
+            // The returned close also wins a race against the subscribe resolving, and closing
+            // the consumer generator propagates through the client and transport to tear down
+            // the server-side subscription.
             return new Observable((observer)=>{
-                let cancelled = false;
-                let generator;
-                source.subscribe(params).then((result)=>{
-                    if (Symbol.asyncIterator in result) {
-                        generator = result;
-                        // Unsubscribe may win the race against this resolution: close the
-                        // server subscription immediately rather than draining it forever.
-                        if (cancelled) {
-                            void generator.return?.(undefined);
-                            return;
-                        }
-                        ;
-                        (async ()=>{
-                            try {
-                                for await (const value of generator){
-                                    if (cancelled) break;
-                                    observer.next(value);
-                                }
-                                if (!cancelled) {
-                                    observer.complete();
-                                }
-                            } catch (err) {
-                                if (!cancelled) {
-                                    observer.error(err);
-                                }
-                            }
-                        })();
-                    } else {
-                        observer.next(result);
-                        observer.complete();
-                    }
-                }, (err)=>{
-                    observer.error(err);
+                return runRecoveringSubscription({
+                    interruptedBackoff: options.interruptedBackoff,
+                    failedBackoff: options.failedBackoff,
+                    schedule: options.schedule,
+                    subscribe: ()=>source.subscribe(params),
+                    rebaseline: ()=>rebaseline(operation),
+                    next: (value)=>observer.next(value),
+                    error: (error)=>observer.error(error),
+                    complete: ()=>observer.complete()
                 });
-                // Closing the consumer generator propagates through the client and
-                // transport to tear down the server-side subscription.
-                return ()=>{
-                    cancelled = true;
-                    void generator?.return?.(undefined);
-                };
             });
         }
         // query or mutation -- route to the appropriate source method

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/with-apollo",
-  "version": "0.17.2",
+  "version": "0.18.0",
   "keywords": [],
   "license": "see LICENSE.md",
   "sideEffects": false,
@@ -15,16 +15,16 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@apollo/client": "^4.3.1",
+    "@apollo/client": "^4.3.5",
+    "@kubun/client": "^0.18.0",
     "graphql": "^17.0.2"
   },
   "devDependencies": {
-    "@enkaku/transport": "^0.21.0",
-    "@kubun/client": "^0.17.2",
-    "@kubun/engine": "^0.17.2",
-    "@kubun/plugin-service-server": "^0.17.1",
-    "@kubun/protocol": "^0.17.1",
-    "@kubun/service-graph-api": "^0.17.2",
+    "@enkaku/transport": "^0.21.5",
+    "@kubun/engine": "^0.18.0",
+    "@kubun/plugin-service-server": "^0.18.0",
+    "@kubun/protocol": "^0.18.0",
+    "@kubun/service-graph-api": "^0.18.0",
     "@kubun/test-utils": "^0.0.0"
   },
   "publishConfig": {