@kubun/with-apollo 0.10.0 → 0.11.0

package/lib/index.js

@@ -1 +1,82 @@
-import{ApolloLink as e,Observable as r}from"@apollo/client";import{getMainDefinition as t,print as n}from"@apollo/client/utilities";function i(e){return new r(r=>{e.then(e=>{try{r.next(e),r.complete()}catch(e){r.error(e)}},e=>{r.error(e)})})}export function createLink(o){return new e(e=>{let a=t(e.query);if("OperationDefinition"!==a.kind){var c;return c=Error(`Invalid definition: ${a.kind}, expected OperationDefinition`),new r(e=>{e.error(c)})}let l={text:n(e.query),variables:e.variables};return"subscription"===a.operation?new r(e=>{o.subscribe(l).then(r=>{Symbol.asyncIterator in r?(async()=>{try{for await(let t of r)e.next(t);e.complete()}catch(r){e.error(r)}})():(e.next(r),e.complete())},r=>{e.error(r)})}):"mutation"===a.operation?i(o.mutate(l)):i(o.query(l))})}
+import { ApolloLink, Observable } from '@apollo/client';
+import { getMainDefinition, print } from '@apollo/client/utilities';
+function toObservable(promise) {
+    return new Observable((observer)=>{
+        promise.then((result)=>{
+            try {
+                observer.next(result);
+                observer.complete();
+            } catch (err) {
+                observer.error(err);
+            }
+        }, (err)=>{
+            observer.error(err);
+        });
+    });
+}
+function observableWithError(error) {
+    return new Observable((subscriber)=>{
+        subscriber.error(error);
+    });
+}
+export function createLink(source) {
+    return new ApolloLink((operation)=>{
+        const definition = getMainDefinition(operation.query);
+        if (definition.kind !== 'OperationDefinition') {
+            return observableWithError(new Error(`Invalid definition: ${definition.kind}, expected OperationDefinition`));
+        }
+        const params = {
+            text: print(operation.query),
+            variables: operation.variables
+        };
+        if (definition.operation === '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);
+                });
+                // 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.query(params));
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/with-apollo",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "license": "see LICENSE.md",
   "keywords": [],
   "type": "module",
@@ -15,19 +15,24 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@apollo/client": "^4.2.0",
-    "graphql": "^16.13.2"
+    "@apollo/client": "^4.2.5",
+    "graphql": "^16.14.2"
   },
   "devDependencies": {
-    "@kubun/protocol": "^0.10.0"
+    "@enkaku/transport": "^0.18.1",
+    "@kubun/client": "^0.11.0",
+    "@kubun/engine": "^0.11.0",
+    "@kubun/protocol": "^0.11.0",
+    "@kubun/plugin-rpc": "^0.11.0",
+    "@kubun/test-utils": "^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 --skipLibCheck",
     "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
-    "test:types": "tsc --noEmit --skipLibCheck",
+    "test:types": "tsc --noEmit --skipLibCheck -p tsconfig.test.json",
     "test:unit": "vitest run",
     "test": "pnpm run test:types && pnpm run test:unit"
   }