@kubun/with-apollo 0.17.1 → 0.18.0

package/lib/index.d.ts

@@ -1,3 +1,26 @@
 import { ApolloLink } from '@apollo/client';
+import { type SubscriptionRecoveryOptions } from '@kubun/client';
 import type { GraphQLSource } from '@kubun/protocol';
-export declare function createLink(source: GraphQLSource): ApolloLink;
+/**
+ * The connector operation-envelope ids a mutation carries (see
+ * `GraphQLOperationParams.operationID`): required on a connector action
+ * mutation, the same pair on every retry of one user intent, a new pair for a
+ * new intent.
+ */
+export type OperationEnvelope = {
+    operationID: string;
+    deterministicEventID: string;
+};
+/**
+ * The Apollo operation `context` that carries an operation envelope to the
+ * link, for a mutation (`client.mutate({ context })` / `useMutation`).
+ */
+export declare function operationEnvelopeContext(envelope: OperationEnvelope): Record<string, unknown>;
+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,33 @@
 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
+ * link, for a mutation (`client.mutate({ context })` / `useMutation`).
+ */ export function operationEnvelopeContext(envelope) {
+    return {
+        [OPERATION_ENVELOPE_KEY]: {
+            operationID: envelope.operationID,
+            deterministicEventID: envelope.deterministicEventID
+        }
+    };
+}
+// The operation envelope an operation's context carries, each id only when it
+// is a string.
+function operationEnvelopeFrom(context) {
+    const envelope = context[OPERATION_ENVELOPE_KEY];
+    const operationID = envelope?.operationID;
+    const deterministicEventID = envelope?.deterministicEventID;
+    return {
+        ...typeof operationID === 'string' ? {
+            operationID
+        } : {},
+        ...typeof deterministicEventID === 'string' ? {
+            deterministicEventID
+        } : {}
+    };
+}
 function toObservable(promise) {
     return new Observable((observer)=>{
         promise.then((result)=>{
@@ -19,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') {
@@ -30,52 +63,29 @@ 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
         if (definition.operation === 'mutation') {
-            return toObservable(source.mutate(params));
+            return toObservable(source.mutate({
+                ...params,
+                ...operationEnvelopeFrom(operation.getContext())
+            }));
         }
         return toObservable(source.query(params));
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/with-apollo",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "keywords": [],
   "license": "see LICENSE.md",
   "sideEffects": false,
@@ -15,16 +15,16 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@apollo/client": "^4.3.0",
+    "@apollo/client": "^4.3.5",
+    "@kubun/client": "^0.18.0",
     "graphql": "^17.0.2"
   },
   "devDependencies": {
-    "@enkaku/transport": "^0.21.0",
-    "@kubun/client": "^0.17.1",
-    "@kubun/engine": "^0.17.1",
-    "@kubun/plugin-service-server": "^0.17.0",
-    "@kubun/protocol": "^0.17.0",
-    "@kubun/service-graph-api": "^0.17.1",
+    "@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": {