@kubun/with-relay 0.9.0 → 0.11.0

package/lib/index.js

@@ -1 +1,78 @@
-import{Environment as r,Network as e,Observable as t,RecordSource as n,Store as o}from"relay-runtime";export function createNetwork(r){let{source:n}=r;return e.create((r,e)=>{let o=r.text;if(null==o)return t.create(r=>{r.error(Error("Relay request is missing query text"))});let a={text:o,variables:e},i="mutation"===r.operationKind?n.mutate(a):n.query(a);return t.from(i)},(r,e)=>{let o=r.text;return null==o?t.create(r=>{r.error(Error("Relay request is missing query text"))}):t.create(r=>{n.subscribe({text:o,variables:e}).then(e=>{if(Symbol.asyncIterator in e){let t=!1;return(async()=>{try{for await(let n of e){if(t)break;r.next(n)}t||r.complete()}catch(e){t||r.error(e instanceof Error?e:Error(String(e)))}})(),()=>{t=!0}}r.next(e),r.complete()},e=>{r.error(e instanceof Error?e:Error(String(e)))})})})}export function createEnvironment(e){let{store:t,...a}=e;return new r({network:createNetwork(a),store:t??new o(new n)})}
+import { Environment, Network, Observable, RecordSource, Store } from 'relay-runtime';
+export function createNetwork(params) {
+    const { source } = params;
+    return Network.create((request, variables)=>{
+        const text = request.text;
+        if (text == null) {
+            return Observable.create((sink)=>{
+                sink.error(new Error('Relay request is missing query text'));
+            });
+        }
+        const params = {
+            text,
+            variables: variables
+        };
+        const promise = request.operationKind === 'mutation' ? source.mutate(params) : source.query(params);
+        return Observable.from(promise);
+    }, (request, variables)=>{
+        const text = request.text;
+        if (text == null) {
+            return Observable.create((sink)=>{
+                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);
+            };
+        });
+    });
+}
+export function createEnvironment(params) {
+    const { store, ...networkParams } = params;
+    return new Environment({
+        network: createNetwork(networkParams),
+        store: store ?? new Store(new RecordSource())
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/with-relay",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "license": "see LICENSE.md",
   "keywords": [],
   "type": "module",
@@ -15,21 +15,25 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "relay-runtime": "^20.1.1"
+    "relay-runtime": "^21.0.1"
   },
   "devDependencies": {
-    "@types/relay-runtime": "^20.1.1",
-    "@kubun/protocol": "^0.9.0",
-    "@kubun/engine": "^0.9.0",
-    "@kubun/test-utils": "^0.9.0"
+    "@enkaku/transport": "^0.18.1",
+    "graphql": "^16.14.2",
+    "@kubun/engine": "^0.11.0",
+    "@kubun/client": "^0.11.0",
+    "@kubun/models": "^0.11.0",
+    "@kubun/protocol": "^0.11.0",
+    "@kubun/test-utils": "^0.11.0",
+    "@kubun/plugin-rpc": "^0.11.0"
   },
   "scripts": {
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
     "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
     "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
-    "test:types": "tsc --noEmit -p tsconfig.test.json",
+    "test:types": "tsc --noEmit --skipLibCheck -p tsconfig.test.json",
     "test:unit": "vitest run",
     "test": "pnpm run test:types && pnpm run test:unit"
   }