@kubun/with-relay 0.17.0 → 0.18.0

package/lib/index.d.ts

@@ -1,10 +1,37 @@
+import { type SubscriptionRecoveryOptions } from '@kubun/client';
 import type { GraphQLSource } from '@kubun/protocol';
-import { Environment, type INetwork, Store } from 'relay-runtime';
-export type NetworkParams = {
+import { type CacheConfig, Environment, type INetwork, Store } from 'relay-runtime';
+export type NetworkParams = SubscriptionRecoveryOptions & {
     source: GraphQLSource;
+    /**
+     * Makes the store consistent again after a subscription recovered: events sent while it
+     * was down are lost. Without it a subscription does not recover, and its interruption
+     * reaches the subscriber as an error.
+     */
+    rebaseline?: () => Promise<unknown>;
 };
-export type EnvironmentParams = NetworkParams & {
+export type EnvironmentParams = Omit<NetworkParams, 'rebaseline'> & {
     store?: Store;
+    /**
+     * Makes the store consistent again after a subscription recovered. Defaults to
+     * invalidating the store, so each query is fetched again the next time it is read.
+     */
+    rebaseline?: (environment: Environment) => Promise<unknown>;
 };
+/**
+ * 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 Relay `cacheConfig` that carries an operation envelope to the network
+ * layer, for a mutation commit (`commitMutation` / `useMutation`).
+ */
+export declare function operationEnvelopeCacheConfig(envelope: OperationEnvelope): CacheConfig;
 export declare function createNetwork(params: NetworkParams): INetwork;
 export declare function createEnvironment(params: EnvironmentParams): Environment;

package/lib/index.js

@@ -1,7 +1,34 @@
-import { Environment, Network, Observable, RecordSource, Store } from 'relay-runtime';
+import { runRecoveringSubscription } from '@kubun/client';
+import { commitLocalUpdate, Environment, Network, Observable, RecordSource, Store } from 'relay-runtime';
+/**
+ * The Relay `cacheConfig` that carries an operation envelope to the network
+ * layer, for a mutation commit (`commitMutation` / `useMutation`).
+ */ export function operationEnvelopeCacheConfig(envelope) {
+    return {
+        metadata: {
+            operationID: envelope.operationID,
+            deterministicEventID: envelope.deterministicEventID
+        }
+    };
+}
+// The operation envelope a mutation's `cacheConfig` carries, each id only
+// when it is a string.
+function operationEnvelopeFrom(cacheConfig) {
+    const metadata = cacheConfig?.metadata;
+    const operationID = metadata?.operationID;
+    const deterministicEventID = metadata?.deterministicEventID;
+    return {
+        ...typeof operationID === 'string' ? {
+            operationID
+        } : {},
+        ...typeof deterministicEventID === 'string' ? {
+            deterministicEventID
+        } : {}
+    };
+}
 export function createNetwork(params) {
-    const { source } = params;
-    return Network.create((request, variables)=>{
+    const { source, rebaseline, ...recovery } = params;
+    return Network.create((request, variables, cacheConfig)=>{
         const text = request.text;
         if (text == null) {
             return Observable.create((sink)=>{
@@ -12,7 +39,10 @@ export function createNetwork(params) {
             text,
             variables: variables
         };
-        const promise = request.operationKind === 'mutation' ? source.mutate(params) : source.query(params);
+        const promise = request.operationKind === 'mutation' ? source.mutate({
+            ...params,
+            ...operationEnvelopeFrom(cacheConfig)
+        }) : source.query(params);
         return Observable.from(promise);
     }, (request, variables)=>{
         const text = request.text;
@@ -21,58 +51,35 @@ export function createNetwork(params) {
                 sink.error(new Error('Relay request is missing query text'));
             });
         }
-        return Observable.create((sink)=>{
-            let disposed = false;
-            let generator;
-            source.subscribe({
-                text,
-                variables: variables
-            }).then((result)=>{
-                if (Symbol.asyncIterator in result) {
-                    generator = result;
-                    // Dispose may win the race against this resolution: close the
-                    // server subscription immediately rather than draining it forever.
-                    if (disposed) {
-                        void generator.return?.(undefined);
-                        return;
-                    }
-                    ;
-                    (async ()=>{
-                        try {
-                            for await (const value of generator){
-                                if (disposed) break;
-                                sink.next(value);
-                            }
-                            if (!disposed) {
-                                sink.complete();
-                            }
-                        } catch (error) {
-                            if (!disposed) {
-                                sink.error(error instanceof Error ? error : new Error(String(error)));
-                            }
-                        }
-                    })();
-                    return;
-                }
-                sink.next(result);
-                sink.complete();
-            }, (error)=>{
-                sink.error(error instanceof Error ? error : new Error(String(error)));
-            });
-            // Closing the consumer generator propagates through the client and
-            // transport to tear down the server-side subscription. The `disposed`
-            // flag still guards sink.next/complete/error after teardown.
-            return ()=>{
-                disposed = true;
-                void generator?.return?.(undefined);
-            };
-        });
+        const subscriptionParams = {
+            text,
+            variables: variables
+        };
+        // 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 Observable.create((sink)=>runRecoveringSubscription({
+                ...recovery,
+                subscribe: ()=>source.subscribe(subscriptionParams),
+                rebaseline,
+                next: (value)=>sink.next(value),
+                error: (error)=>sink.error(error),
+                complete: ()=>sink.complete()
+            }));
     });
 }
+function invalidateStore(environment) {
+    commitLocalUpdate(environment, (store)=>store.invalidateStore());
+    return Promise.resolve();
+}
 export function createEnvironment(params) {
-    const { store, ...networkParams } = params;
-    return new Environment({
-        network: createNetwork(networkParams),
+    const { store, rebaseline = invalidateStore, ...networkParams } = params;
+    const environment = new Environment({
+        network: createNetwork({
+            ...networkParams,
+            rebaseline: ()=>rebaseline(environment)
+        }),
         store: store ?? new Store(new RecordSource())
     });
+    return environment;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/with-relay",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "keywords": [],
   "license": "see LICENSE.md",
   "sideEffects": false,
@@ -15,18 +15,23 @@
     "LICENSE.md"
   ],
   "dependencies": {
+    "@kubun/client": "^0.18.0",
     "relay-runtime": "^21.0.1"
   },
   "devDependencies": {
-    "@enkaku/transport": "^0.21.0",
-    "@kubun/client": "^0.17.0",
-    "@kubun/engine": "^0.17.0",
-    "@kubun/models": "^0.17.0",
-    "@kubun/plugin-service-server": "^0.17.0",
-    "@kubun/protocol": "^0.17.0",
-    "@kubun/service-graph-api": "^0.17.0",
+    "@enkaku/transport": "^0.21.5",
+    "@kubun/engine": "^0.18.0",
+    "@kubun/models-calendar": "^0.18.0",
+    "@kubun/models-contacts": "^0.18.0",
+    "@kubun/models-content": "^0.18.0",
+    "@kubun/models-core": "^0.18.0",
+    "@kubun/models-messaging": "^0.18.0",
+    "@kubun/models-tasks": "^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",
-    "graphql": "^16.14.2"
+    "graphql": "^17.0.2"
   },
   "publishConfig": {
     "access": "public"