@envelop/on-resolve 2.0.0-alpha-20220907123006-46eb16d1

package/README.md

@@ -0,0 +1,98 @@
+## `@envelop/on-resolve`
+
+This plugin allows you to hook into resolves of every field in the GraphQL schema.
+
+Useful for tracing or augmenting resolvers (and their results) with custom logic.
+
+## Getting Started
+
+```
+yarn add @envelop/on-resolve
+```
+
+## Usage Example
+
+### Custom field resolutions
+
+```ts
+import { envelop } from '@envelop/core'
+import { useOnResolve } from '@envelop/on-resolve'
+import { specialResolver } from './my-resolvers'
+
+const getEnveloped = envelop({
+  plugins: [
+    // ... other plugins ...
+    useOnResolve(async function onResolve({ context, root, args, info, replaceResolver }) {
+      // replace special field's resolver
+      if (info.fieldName === 'special') {
+        replaceResolver(specialResolver)
+      }
+
+      // replace field's result
+      if (info.fieldName === 'alwaysHello') {
+        return ({ setResult }) => {
+          setResult('hello')
+        }
+      }
+    })
+  ]
+})
+```
+
+### Tracing
+
+```ts
+import { envelop, Plugin } from '@envelop/core'
+import { useOnResolve } from '@envelop/on-resolve'
+
+interface FieldTracingPluginContext {
+  tracerUrl: string
+}
+
+function useFieldTracing() {
+  return {
+    onPluginInit({ addPlugin }) {
+      addPlugin(
+        useOnResolve(async function onResolve({ context, root, args, info }) {
+          await fetch(context.tracerUrl, {
+            method: 'POST',
+            headers: {
+              'content-type': 'application/json'
+            },
+            body: JSON.stringify({
+              startedResolving: {
+                ...info,
+                parent: root,
+                args
+              }
+            })
+          })
+
+          return async () => {
+            await fetch(context.tracerUrl, {
+              method: 'POST',
+              headers: {
+                'content-type': 'application/json'
+              },
+              body: JSON.stringify({
+                endedResolving: {
+                  ...info,
+                  parent: root,
+                  args
+                }
+              })
+            })
+          }
+        })
+      )
+    }
+  }
+}
+
+const getEnveloped = envelop({
+  plugins: [
+    // ... other plugins ...
+    useSpecialResolve()
+  ]
+})
+```

package/cjs/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOnResolve = void 0;
+const graphql_1 = require("graphql");
+/**
+ * Wraps the provided schema by hooking into the resolvers of every field.
+ *
+ * Use the `onResolve` argument to manipulate the resolver and its results/errors.
+ */
+function useOnResolve(onResolve) {
+    return {
+        onSchemaChange({ schema: _schema }) {
+            const schema = _schema;
+            if (!schema)
+                return; // nothing to do if schema is missing
+            for (const type of Object.values(schema.getTypeMap())) {
+                if (!(0, graphql_1.isIntrospectionType)(type) && (0, graphql_1.isObjectType)(type)) {
+                    for (const field of Object.values(type.getFields())) {
+                        let resolver = (field.resolve || graphql_1.defaultFieldResolver);
+                        field.resolve = async (root, args, context, info) => {
+                            const afterResolve = await onResolve({
+                                root,
+                                args,
+                                context,
+                                info,
+                                resolver,
+                                replaceResolver: newResolver => {
+                                    resolver = newResolver;
+                                },
+                            });
+                            let result;
+                            try {
+                                result = await resolver(root, args, context, info);
+                            }
+                            catch (err) {
+                                result = err;
+                            }
+                            if (typeof afterResolve === 'function') {
+                                await afterResolve({
+                                    result,
+                                    setResult: newResult => {
+                                        result = newResult;
+                                    },
+                                });
+                            }
+                            if (result instanceof Error) {
+                                throw result;
+                            }
+                            return result;
+                        };
+                    }
+                }
+            }
+        },
+    };
+}
+exports.useOnResolve = useOnResolve;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/esm/index.js

@@ -0,0 +1,53 @@
+import { defaultFieldResolver, isIntrospectionType, isObjectType } from 'graphql';
+/**
+ * Wraps the provided schema by hooking into the resolvers of every field.
+ *
+ * Use the `onResolve` argument to manipulate the resolver and its results/errors.
+ */
+export function useOnResolve(onResolve) {
+    return {
+        onSchemaChange({ schema: _schema }) {
+            const schema = _schema;
+            if (!schema)
+                return; // nothing to do if schema is missing
+            for (const type of Object.values(schema.getTypeMap())) {
+                if (!isIntrospectionType(type) && isObjectType(type)) {
+                    for (const field of Object.values(type.getFields())) {
+                        let resolver = (field.resolve || defaultFieldResolver);
+                        field.resolve = async (root, args, context, info) => {
+                            const afterResolve = await onResolve({
+                                root,
+                                args,
+                                context,
+                                info,
+                                resolver,
+                                replaceResolver: newResolver => {
+                                    resolver = newResolver;
+                                },
+                            });
+                            let result;
+                            try {
+                                result = await resolver(root, args, context, info);
+                            }
+                            catch (err) {
+                                result = err;
+                            }
+                            if (typeof afterResolve === 'function') {
+                                await afterResolve({
+                                    result,
+                                    setResult: newResult => {
+                                        result = newResult;
+                                    },
+                                });
+                            }
+                            if (result instanceof Error) {
+                                throw result;
+                            }
+                            return result;
+                        };
+                    }
+                }
+            }
+        },
+    };
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@envelop/on-resolve",
+  "version": "2.0.0-alpha-20220907123006-46eb16d1",
+  "sideEffects": false,
+  "peerDependencies": {
+    "@envelop/core": "3.0.0-alpha-20220907123006-46eb16d1",
+    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
+  },
+  "dependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/n1ru4l/envelop.git",
+    "directory": "packages/plugins/on-resolve"
+  },
+  "author": "Denis Badurina <badurinadenis@gmail.com>",
+  "license": "MIT",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    },
+    "./*": {
+      "require": {
+        "types": "./typings/*.d.cts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      }
+    },
+    "./package.json": "./package.json"
+  }
+}

package/typings/index.d.cts

@@ -0,0 +1,22 @@
+import { GraphQLResolveInfo } from 'graphql';
+import { Plugin, PromiseOrValue } from '@envelop/core';
+export declare type Resolver<Context = unknown> = (root: unknown, args: Record<string, unknown>, context: Context, info: GraphQLResolveInfo) => PromiseOrValue<unknown>;
+export declare type AfterResolver = (options: {
+    result: unknown;
+    setResult: (newResult: unknown) => void;
+}) => PromiseOrValue<void>;
+export interface OnResolveOptions<PluginContext extends Record<string, any> = {}> {
+    context: PluginContext;
+    root: unknown;
+    args: Record<string, unknown>;
+    info: GraphQLResolveInfo;
+    resolver: Resolver<PluginContext>;
+    replaceResolver: (newResolver: Resolver<PluginContext>) => void;
+}
+export declare type OnResolve<PluginContext extends Record<string, any> = {}> = (options: OnResolveOptions<PluginContext>) => PromiseOrValue<AfterResolver | void>;
+/**
+ * Wraps the provided schema by hooking into the resolvers of every field.
+ *
+ * Use the `onResolve` argument to manipulate the resolver and its results/errors.
+ */
+export declare function useOnResolve<PluginContext extends Record<string, any> = {}>(onResolve: OnResolve<PluginContext>): Plugin<PluginContext>;

package/typings/index.d.ts

@@ -0,0 +1,22 @@
+import { GraphQLResolveInfo } from 'graphql';
+import { Plugin, PromiseOrValue } from '@envelop/core';
+export declare type Resolver<Context = unknown> = (root: unknown, args: Record<string, unknown>, context: Context, info: GraphQLResolveInfo) => PromiseOrValue<unknown>;
+export declare type AfterResolver = (options: {
+    result: unknown;
+    setResult: (newResult: unknown) => void;
+}) => PromiseOrValue<void>;
+export interface OnResolveOptions<PluginContext extends Record<string, any> = {}> {
+    context: PluginContext;
+    root: unknown;
+    args: Record<string, unknown>;
+    info: GraphQLResolveInfo;
+    resolver: Resolver<PluginContext>;
+    replaceResolver: (newResolver: Resolver<PluginContext>) => void;
+}
+export declare type OnResolve<PluginContext extends Record<string, any> = {}> = (options: OnResolveOptions<PluginContext>) => PromiseOrValue<AfterResolver | void>;
+/**
+ * Wraps the provided schema by hooking into the resolvers of every field.
+ *
+ * Use the `onResolve` argument to manipulate the resolver and its results/errors.
+ */
+export declare function useOnResolve<PluginContext extends Record<string, any> = {}>(onResolve: OnResolve<PluginContext>): Plugin<PluginContext>;