Merge pull request #109 from tlivings/ts-conversion

Ts conversion

Author: tlivings

.github/workflows/nodejs.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [12.x]
+        node-version: [18.x]
     steps:
     - uses: actions/checkout@v2
     - name: Use Node.js ${{ matrix.node-version }}

.github/workflows/npmpublish.yml

@@ -14,7 +14,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v1
         with:
-          node-version: 12
+          node-version: 18
       - run: npm install
       - run: npm run lint
       - run: npm run cover
@@ -26,21 +26,20 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v1
         with:
-          node-version: 12
+          node-version: 18
           registry-url: https://registry.npmjs.org/
       - run: npm install
       - run: npm publish
         env:
           NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}
-
 #   publish-gpr:
 #     needs: build
 #     runs-on: ubuntu-latest
 #     steps:
 #       - uses: actions/checkout@v2
 #       - uses: actions/setup-node@v1
 #         with:
-#           node-version: 12
+#           node-version: 18
 #           registry-url: https://npm.pkg.github.com/
 #       - run: npm ci
 #       - run: npm publish

CHANGELOG.md

@@ -3,4 +3,189 @@
 - Converted to TS
 - BREAKING removed `delegateToComponent`
 - BREAKING excludes removed as an option in import configuration. Transforms used instead as part of a `SubschemaConfig`.
-- BREAKING upgraded to graphql 16.9+ peer
+- BREAKING upgraded to graphql 16.9+ peer
+
+===
+
+### v5.0.1
+
+- Update @graphql-tools/utils dependency and fix samples for Apollo server v3.
+
+### v5.0.0
+
+- Update graphql peer-dependency for Apollo server v3.
+
+### v4.0.0
+
+- Updated @apollo/federation dependency for Node 18 compatibility.
+- Drop Node 12 compatibility.
+
+### v3.1.0
+
+- Updated graphql-tools dependency to fix security vulnerabilities
+
+### v3.0.4
+
+- Updated schema pruning dependency and TS definitions
+
+### v3.0.3
+
+- [FIXED] - imported components directives are merged into final schema
+
+### v3.0.2
+
+- schema pruning and remove broken makeExecutableSchema override
+
+### v3.0.1
+
+- [FIXED] - if `exclude` is undefined in a component config
+
+### v3.0.0
+
+- Modernized to utilize new graphql-tools
+- [BREAKING] - directives are not imported and maintained throughout the tree : top level component is responsible for directive implementations
+
+### v2.2.0
+
+- [FEATURE] - Add "hook" for custom `makeExecutableSchema` function
+
+### v2.1.7
+
+- [FIXED] - Explicitly removed wrapping of the federation `__resolveReference()` resolver which was preventing `__resolveReference()` from running when using `graphql-component` to build federated schemas in seperate graphql services.
+
+### v2.1.6
+
+- [FIXED] - A bug with `graphql-component` being used in a federated schema was brought to our attention and was attributed to the non-root type field resolver wrapping performed to help prevent double execution of resolvers with local delegation. Effectively, the resolver wrapping functionality was causing a null value to be returned (by attempting to return a value from the root arg) when the wrapper should have been calling through to the actual resolver. To fix this, separate wrapper functions are used for fields that begin with `__` (such as `__resolveType()`) versus "normal" non-root type fields. These separated wrapper functions look for similar but slightly different conditions to determine whether to "short circuit" an already computed result which ensures that the wrapper functions are short circuiting or calling through to the actual resolver in the desired situations.
+
+### v2.1.5
+
+- [FIXED] - delegateToComponent()'s second parameter is an options object that supports an `args` key for passing arguments to the target GraphQL operation via JavaScript from the calling resolver. Previously, if you attempted to pass an array (wrapping any form of JavaScript scalar) a type coersion error would surface. delegateToComponent's options.args parameter now supports passing Array like arguments as expected.
+
+### v2.1.4
+
+- [REVERT] - reverting both fixes in [2.1.2](https://github.com/ExpediaGroup/graphql-component/releases/tag/v2.1.2). The change made to unify exclusions and return pre-computed results from non-root resolvers resulted in non-root resolvers not executing when they should have. Being able to exclude non-root resolvers (not their types) is a valid work around in certain situations.
+
+### v2.1.3
+
+- [FIXED] - modified automatic pruning mechanism during delegation to use parent types/parent type fields instead of getFieldDef()
+
+### v2.1.2
+
+- [FIXED] - non-root resolvers being executed twice in certain delegate situations
+- [FIXED] - resolver exclusion now works identical to type exclusion. Only root types (`Query`, `Mutation`, `Subscription`) and/or fields on root types can be excluded, which was not the case for resolver functions prior to this fix.
+
+### v2.1.1
+
+- update `@apollo/federation` to `^0.20.4`
+
+### v2.1.0
+
+- [FEATURE] `delegateToComponent()` - automatically prune fields from the delegated document selection set that are not defined in the schema (component) being delegated to. This will reduced potential down stream errors as well as ensures no unintended fields are forwarded and all fields forwarded can be resolved by the schema be delegated to. This feature addresses some edge cases around variable forwarding that were not addressed in prior patch releases `2.0.4` and `2.0.5`.
+
+### v2.0.5
+
+- [FIXED] Reinstated variable passing to the sub-document created by `delegateToComponent()`. All variable values will be forwarded to the delegated operation, but only the variable definitions for input types or types that are in the target schema will be forwarded. This prevents errors in certain delegate situations while also allowing valid resolution of args passed as variables.
+
+### v2.0.4
+
+- [FIXED] the error path on errors surfaced through `delegateToComponent()` calls such that error path takes into account the already traversed path and exclusions
+- [FIXED] Variables from an outer operation are no longer forwarded to the sub operation created by `delegateToComponent()` this is to avoid passing along variables for types that dont exist in the schema being delegated to.
+
+### v2.0.3
+
+- [FIXED] individual field exclusions during import - individual field exclusions will no longer modify the original resolver map that is being imported.
+- [FIXED] tightened up argument forwarding when using `delegateToComponent()` - only arguments the target field is expecting will be extracted from the calling resolver or from the `args` object provided to `delegateToComponent()` depending on the situation. Previously, there were some unintended argument leakage in certain edge cases.
+
+### v2.0.2
+
+- [FIXED] importing directives
+
+### v2.0.1
+
+- [FIXED] error merging to iteratively consider the merge path to properly merge errors in complex situations such as lists
+
+### v2.0.0
+
+- [BREAKING] removed fragment helpers
+- [BREAKING] `schemaDirectives` (which returned merged directives) removed from component api
+- [BREAKING] removed `proxyImportedResolvers` feature flag
+- [BREAKING] removed `execute`
+- [FEATURE] added `delegateToComponent` to replace `execute`
+- [FEATURE] args can be overridden/passed via `delegateToComponent`
+- [FEATURE] added `targetRootField` option to `delegateToComponent`
+- [FIXED] delegation for subscription operations
+- [FIXED] Memoizing resolvers didn't take into account aliased requests
+- [FIXED] delegating an operation that contains an abstract type
+- [DOCS] added documentation for `delegateToComponent`
+- [CLEANUP] use fieldNodes to build sub-operation document in delegateToComponent such that the original operation document isn't unintentionally modified
+- [CLEANUP] removal of proxy resolvers creation when importing resolvers
+- [CLEANUP] Refactor how imports are merged together to be optimized and only run when a schema is requested
+- [CLEANUP] Moved tests alongside source code
+
+### v1.3.1
+
+- Fixed exclude mapping in GraphQLComponent constructor - Array.map was erroniously changed to Array.filter
+
+### v1.3.0
+
+- Imported resolvers will delegate to the imported component schema to which they belong.
+- Remove `this._context` as default value for context in `execute()` requiring `execute()` users to pass in context from a calling resolver.
+- Remove binding of `GraphQLComponent` class context to Subscription resolvers.
+- Apply proxyImportedResolvers regardless of how the way a component is imported and whether or not exclusions are provided. proxyImportedResolvers can still be turned off for an imported component if the component is passed via config object.
+
+### v1.2.4
+
+- Execute flag `mergeErrors` allows inline errors to facilitate returning multiple errors from resolvers that use `execute`.
+
+### v1.2.3
+
+- Allow extended properties in federated schema with custom directives
+
+### v1.2.2
+
+- Allow custom directives in federation (#40)
+
+### v1.2.1
+
+- Clean up empty types that were excluded (#38)
+- Reduced package size with npmignore
+
+### v1.2.0
+
+- Added federation support
+- New license copyright
+
+### v1.1.3
+
+- Fixed data source proxy losing instance binding
+- Upgraded to graphql peer ^14
+
+### v1.1.1
+
+- `execute` now supports both document objects and strings.
+
+### v1.1.1
+
+- [BREAKING from 1.1.0 (sorry, but it is 5 minutes later)]: data sources appear by constructor name on context
+
+### v1.1.0
+
+- Added first class data source support and overriding
+
+### v1.0.4
+
+- Fixes #23
+
+### v1.0.3
+
+- Disabling type resolvers from memoization — this doesn't work right for type resolvers.
+
+### v1.0.2
+
+- Outer global context setup occurs only once when `context` is fetched off component.
+
+### v1.0.1
+
+- Fixed .npmignore to not include misc files that added to the package size
+
+### v1.0.0 — promoted from alpha.23

README.md

@@ -2,11 +2,11 @@
 
 # GraphQL schema components.
 
-This project is designed to faciliate componentized or modularized development of GraphQL schemas.
+This project is designed to facilitate componentized or modularized development of GraphQL schemas.
 
 Read more about the idea [here](https://medium.com/expedia-group-tech/graphql-component-architecture-principles-homeaway-ede8a58d6fde).
 
-`graphql-component` lets you build a schema progressively through a tree (faciliated through `imports`) of GraphQLComponent instances. Each GraphQLComponent instance encapsulates an executable GraphQL schema, specifically a `graphql-js` GraphQLSchema object. See the API below, but the encapsulated schema is accessible through a simple `schema` getter on a given `GraphQLComponent` instance.
+`graphql-component` lets you build a schema progressively through a tree (facilitated through `imports`) of GraphQLComponent instances. Each GraphQLComponent instance encapsulates an executable GraphQL schema, specifically a `graphql-js` GraphQLSchema object. See the API below, but the encapsulated schema is accessible through a simple `schema` getter on a given `GraphQLComponent` instance.
 
 Generally speaking, each instance of `GraphQLComponent` has reference to an instance of [`GraphQLSchema`](https://graphql.org/graphql-js/type/#graphqlschema). This instance of `GraphQLSchema` is built in a several ways, depending on the options passed to a given `GraphQLComponent`'s constructor.
 
@@ -31,7 +31,7 @@ federation (2 subschema services implemented via `GraphQLComponent` and a vanill
 
 ### Running examples:
 * composition: `npm run start-composition`
-* fedration: `npm run start-federation`
+* federation: `npm run start-federation`
 * go to `localhost:4000/graphql`
   * for composition this will bring up the GraphQL Playground for a plain old Apollo Server
   * for the federation example this will bring up the GraphQL Playground for an Apollo Federated Gateway
@@ -64,7 +64,7 @@ federation (2 subschema services implemented via `GraphQLComponent` and a vanill
     - `args` (`object`, optional) - an object literal whose keys/values are passed as args to the delegatee's target field resolver. By default, the resolver's args from which `delegateToComponent` is called will be passed if the target field has an argument of the same name. Otherwise, arguments passed via the `args` object will override the calling resolver's args of the same name.
     - `transforms` (optional `Array<Transform>`): Transform being a valid `graphql-tools` transform
 
-  - please see `graphql-tools` [delegateToSchema](https://www.graphql-tools.com/docs/schema-delegation/#delegatetoschema) documentation for more details on available `options` since the delegateToComponent fuctions is simply an adapter for the `GraphQLComponent` API.
+  - please see `graphql-tools` [delegateToSchema](https://www.graphql-tools.com/docs/schema-delegation/#delegatetoschema) documentation for more details on available `options` since the delegateToComponent functions is simply an adapter for the `GraphQLComponent` API.
 
 A GraphQLComponent instance (ie, `new GraphQLComponent({...})`) has the following API:
 
@@ -174,7 +174,7 @@ Data sources in `graphql-component` do not extend `apollo-datasource`'s `DataSou
 Instead, data sources in components will be injected into the context, but wrapped in a proxy such that the global
 context will be injected as the first argument of any function implemented in a data source class.
 
-This allows there to exist one instance of a data source for caching or other statefullness (like circuit breakers),
+This allows there to exist one instance of a data source for caching or other statefulness (like circuit breakers),
 while still ensuring that a data source will have the current context.
 
 For example, a data source should be implemented like:

examples/federation/reviews-service/index.js

@@ -5,6 +5,7 @@ const GraphQLComponent = require('../../../dist').default;
 const ReviewsDataSource = require('./datasource');
 const resolvers = require('./resolvers');
 const types = require('./types');
+const toUppercaseDirective = require('./toUppercaseDirective')
 
 class ReviewsComponent extends GraphQLComponent {
   constructor(options) {
@@ -17,6 +18,9 @@ const run = async function () {
     types,
     resolvers,
     dataSources: [new ReviewsDataSource()],
+    directives: {
+      toUppercase: toUppercaseDirective
+    },
     federation: true
   });
 

examples/federation/reviews-service/schema.graphql

@@ -1,6 +1,8 @@
+directive @toUppercase on FIELD_DEFINITION
+
 type Review {
   id: ID!
-  content: String!
+  content: String! @toUppercase
 }
 
 extend type Property @key(fields: "id") {

examples/federation/reviews-service/toUppercaseDirective.js

@@ -0,0 +1,25 @@
+const {getDirective, MapperKind, mapSchema} = require("@graphql-tools/utils");
+const {defaultFieldResolver} = require("graphql");
+
+function toUppercaseDirective(directiveName) {
+    return (schema) => mapSchema(schema, {
+        [MapperKind.OBJECT_FIELD]: (fieldConfig) => {
+            const upperDirective = getDirective(schema, fieldConfig, directiveName)?.[0];
+            if (upperDirective) {
+                const {resolve = defaultFieldResolver} = fieldConfig;
+                return {
+                    ...fieldConfig,
+                    resolve: async function (source, args, context, info) {
+                        const result = await resolve(source, args, context, info);
+                        if (typeof result === 'string') {
+                            return result.toUpperCase();
+                        }
+                        return result;
+                    }
+                }
+            }
+        }
+    })
+}
+
+module.exports = toUppercaseDirective