jackbeeby/Job_App
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial Save

Browse Source
This commit is contained in:
jackbeeby
2025-03-28 12:30:19 +11:00
parent e381994f19
commit d8773925e8
9910 changed files with 982718 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

454
node_modules/graphql-tools/CHANGELOG.md generated vendored Normal file
View File

@@ -0,0 +1,454 @@
# Change log
### 4.0.8
* Update `peerDependencies` range for `graphql` to include `graphql@15.x`.
### 4.0.7
* Filter `extensions` prior to passing them to `buildASTSchema`, in an effort to provide minimum compatibilty for `graphql@14`-compatible schemas with the upcoming `graphql@15` release. This PR does not, however, bring support for newer `graphql@15` features like interfaces implementing interfaces. [#1284](https://github.com/apollographql/graphql-tools/pull/1284)
### 4.0.6
* Use `getIntrospectionQuery` instead of deprecated `introspectionQuery` constant from graphql-js
[@derek-miller](https://github.com/derek-miller) in [#1228](https://github.com/apollographql/graphql-tools/pull/1228)
### 4.0.5
* Fixes a bug where schemas with scalars could not be merged when passed to
`mergeSchemas` as a string or `GraphQLSchema`. <br/>
[@hayes](https://github.com/hayes) in [#1062](https://github.com/apollographql/graphql-tools/pull/1062)
* Make `mergeSchemas` optionally merge directive definitions. <br/>
[@freiksenet](https://github.com/freiksenet) in [#1003](https://github.com/apollographql/graphql-tools/pull/1003)
* Allow user-provided `buildSchema` options. <br/>
[@trevor-scheer](https://github.com/trevor-scheer) in [#1154](https://github.com/apollographql/graphql-tools/pull/1154)
### 4.0.4
* Make `WrapQuery` work for non-root fields <br />
[@mdlavin](https://github.com/mdlavin) in
[#1007](https://github.com/apollographql/graphql-tools/pull/1008)
* Update resolvers.md to clarify array usage <br />
[@alvin777](https://github.com/alvin777) in
[#1005](https://github.com/apollographql/graphql-tools/pull/1005)
* Add missing property to `mergeSchemas` api reference. <br />
[@PlayMa256](https://github.com/PlayMa256) in
[#1014](https://github.com/apollographql/graphql-tools/pull/1014)
* Documentation updates for mockServer <br/>
[@dougshamoo](https://github.com/dougshamoo) in [#1012](https://github.com/apollographql/graphql-tools/pull/1012)
* Fix default merged resolver behavior <br/>
[@mfix22](https://github.com/mfix22) in [#983](https://github.com/apollographql/graphql-tools/pull/983)
* Use `TArgs` generic wherever `IFieldResolver` is used. <br/>
[@brikou](https://github.com/brikou) in [#955](https://github.com/apollographql/graphql-tools/pull/955)
* Include deprecations from string SDL in mergeSchemas. <br/>
[@evans](https://github.com/evans) in [#1041](https://github.com/apollographql/graphql-tools/pull/1041)
### 4.0.3
* Replaced broken link in docs homepage with Launchpad example <br />
[@kriss1897](https://github.com/kriss1897) in
[#965](https://github.com/apollographql/graphql-tools/pull/965)
* Fix invalid query in schema delegation example. <br />
[@nico29](https://github.com/nico29) in
[#980](https://github.com/apollographql/graphql-tools/pull/980)
* Update package.json `repository` field. <br />
[@dlukeomalley](https://github.com/dlukeomalley) in
[#979](https://github.com/apollographql/graphql-tools/pull/979)
* Add support for passing a parsed schema ast to `mergeSchemas` <br/>
[@ganemone](https://github.com/ganemone) in
[#977](https://github.com/apollographql/graphql-tools/pull/977)
* Changes to `extractExtensionDefinitions` to support `graphql-js` union and enum extensions. <br/>
[@jansuchy](https://github.com/jansuchy) in [#951](https://github.com/apollographql/graphql-tools/pull/951)
* Add docs for `mockServer` (closes [#951](https://github.com/apollographql/graphql-tools/issues/94))<br/>
[@mfix22](https://github.com/mfix22) in [PR #982](https://github.com/apollographql/graphql-tools/pull/982)
* Fix regression where custom scalars were incorrectly replaced while recreating schema with `visitSchema`. <br/>
[@tgriesser](https://github.com/tgriesser) in [#985](https://github.com/apollographql/graphql-tools/pull/985)
### 4.0.2
* Fix regression in enum input mapping. <br/>
[@tgriesser](https://github.com/tgriesser) in [#974](https://github.com/apollographql/graphql-tools/pull/974)
### 4.0.1
* Fix [regression](https://github.com/apollographql/graphql-tools/issues/962) in enum internal value mapping. <br/>
[@tgriesser](https://github.com/tgriesser) in [#973](https://github.com/apollographql/graphql-tools/pull/973)
### 4.0.0
* Support `graphql` and `@types/graphql` 14.x. <br />
**NOTE:** `graphql` 14 includes [breaking changes](https://github.com/graphql/graphql-js/releases/tag/v14.0.0). We're bumping the major version of `graphql-tools` to accommodate those breaking changes. If you're planning on using `graphql` 14 with `graphql-tools` 4.0.0, please make sure you've reviewed the `graphql` breaking changes list.
[@hwillson](https://github.com/hwillson) in [#953](https://github.com/apollographql/graphql-tools/pull/953)
* Fix template strings usage in guessSchemaByRootField error message. <br/>
[@nagelflorian](https://github.com/nagelflorian) in [#936](https://github.com/apollographql/graphql-tools/pull/936)
* Update `IFieldResolver` to allow typed input args. <br/>
[@luk3thomas](https://github.com/luk3thomas) in [#932](https://github.com/apollographql/graphql-tools/pull/932)
* Changes to `extractExtensionDefinitions` to properly support `graphql-js` input extensions. <br/>
[@jure](https://github.com/jure) in [#948](https://github.com/apollographql/graphql-tools/pull/948)
* Stop automatically shallow cloning (via object spread syntax) transformed subscription results. Transformed subscription results are not always objects, which means object spreading can lead to invalid results. <br/>
[@ericlewis](https://github.com/ericlewis) in [#928](https://github.com/apollographql/graphql-tools/pull/928)
* Re-use errors with an `extensions` property to make compatible with Apollo Server and it's built-in errors. <br/>
[@edorsey](https://github.com/edorsey) in [#925](https://github.com/apollographql/graphql-tools/pull/925)
* Documentation updates. <br/>
[@Amorites](https://github.com/Amorites) in [#944](https://github.com/apollographql/graphql-tools/pull/944) <br/>
[@trevor-scheer](https://github.com/trevor-scheer) in [#946](https://github.com/apollographql/graphql-tools/pull/946) <br/>
[@dnalborczyk](https://github.com/dnalborczyk) in [#934](https://github.com/apollographql/graphql-tools/pull/934) <br/>
[@zcei](https://github.com/zcei) in [#933](https://github.com/apollographql/graphql-tools/pull/933)
### v3.1.1
* Revert the added `casual` dependency for mocking, since it was causing issues for people using `graphql-tools` in the browser.
### v3.1.0
* Loosens the apollo-link dependency [PR #765](https://github.com/apollographql/graphql-tools/pull/765)
* Use `getDescription` from `graphql-js` package [PR #672](https://github.com/apollographql/graphql-tools/pull/672)
* Update `IResolvers` to use source & context generics and to support all resolver use cases. [#896](https://github.com/apollographql/graphql-tools/pull/896)
* `WrapQuery`'s `wrapper` param can now return a SelectionSet. [PR #902](https://github.com/apollographql/graphql-tools/pull/902) [Issue #901](https://github.com/apollographql/graphql-tools/issues/901)
* Add null to return type of directive visitors in the TypeScript definition.
* Make sure mergeSchemas keeps Enum descriptions and deprecation status. [PR 898](https://github.com/apollographql/graphql-tools/pull/898/)
* Add `inheritResolversFromInterfaces` option to `mergeSchemas` [PR #812](https://github.com/apollographql/graphql-tools/pull/812)
* Added filtering of empty selection sets in FilterToSchema [#827](https://github.com/apollographql/graphql-tools/pull/827)
* Add support for overlapping fragments in ReplaceFieldWithFragment. [#894](https://github.com/apollographql/graphql-tools/issues/894)
* `delegateToSchema` now behaves like `info.mergeInfo.delegateToSchema` for fragment handling [Issue #876](https://github.com/apollographql/graphql-tools/issues/876) [PR #885](https://github.com/apollographql/graphql-tools/pull/885)
* Make schema transforms work with subscriptions, make it so that subscription errors don't disappear when using mergeSchemas [#793](https://github.com/apollographql/graphql-tools/issues/793) [#780](https://github.com/apollographql/graphql-tools/issues/780)
### v3.0.5
* Update apollo-link to 1.2.2 [#785](https://github.com/apollographql/graphql-tools/pull/785)
### v3.0.4
* Make sure `dist/generate` isn't excluded when published.
### v3.0.3
* Pass on operation name when stitching schemas.
[Issue #522](https://github.com/apollographql/graphql-tools/issues/522)
[PR #849](https://github.com/apollographql/graphql-tools/pull/849)
* Fixed errors that occurred when a fragment field argument used a variable
defined in the parent query.
[Issue #753](https://github.com/apollographql/graphql-tools/issues/753)
[PR #806](https://github.com/apollographql/graphql-tools/pull/806)
### v3.0.2
* Fixed duplicate fragments getting added during transform in `FilterToSchema` [#778](https://github.com/apollographql/graphql-tools/pull/778)
* Fixed a visitType error printing the name of the variable typeName rather than its value due to a template string being incorrectly formatted. [#783](https://github.com/apollographql/graphql-tools/pull/783)
### v3.0.1
* Fixed an array cloning bug in the `RenameTypes` transform
[#756](https://github.com/apollographql/graphql-tools/pull/756)
* Fixed a fragments bug in the `ReplaceFieldWithFragment` transform
[#763](https://github.com/apollographql/graphql-tools/pull/763)
### v3.0.0
* Schema transforms and delegation
* Substantial rewrite of internals of `mergeSchemas` and `delegateToSchema`
* A new API for schema transforms has been introduced: [Docs](https://www.apollographql.com/docs/graphql-tools/schema-transforms.html)
* `delegateToSchema` is now a public API: [Docs](https://www.apollographql.com/docs/graphql-tools/schema-delegation.html)
* `delegateToSchema` now accepts an object of named parameters; positional arguments are deprecated
* `delegateToSchema` no longer accepts `fragmentReplacements`; instead use `transforms`
* `info.mergeInfo.delegateToSchema` is now the preferred delegation API, rather than `info.mergeInfo.delegate`
* Other changes
* Add `commentDescription` to `printSchema` call to match other uses [PR #745](https://github.com/apollographql/graphql-tools/pull/745)
* Add `createResolver` option to `makeRemoteExecutableSchema` [PR #734](https://github.com/apollographql/graphql-tools/pull/734)
### v2.24.0
* Allow `extend interface` definitions in merged schemas [PR #703](https://github.com/apollographql/graphql-tools/pull/703)
* Fix typo in `@deprecated` example in `schema-directives.md` [PR #706](https://github.com/apollographql/graphql-tools/pull/706)
* Fix timezone bug in test for `@date` directive [PR #686](https://github.com/apollographql/graphql-tools/pull/686)
* Expose `defaultMergedResolver` for schema stitching [PR #685](https://github.com/apollographql/graphql-tools/pull/685)
* Add `requireResolversForResolveType` to resolver validation options [PR #698](https://github.com/apollographql/graphql-tools/pull/698)
* Add `inheritResolversFromInterfaces` option to `makeExecutableSchema` and `addResolveFunctionsToSchema` [PR #720](https://github.com/apollographql/graphql-tools/pull/720)
### v2.23.0
* The `SchemaDirectiveVisitor` abstraction for implementing reusable schema `@directive`s has landed. Read our [blog post](https://dev-blog.apollodata.com/reusable-graphql-schema-directives-131fb3a177d1) about this new functionality, and/or check out the [documentation](https://www.apollographql.com/docs/graphql-tools/schema-directives.html) for even more examples. [PR #640](https://github.com/apollographql/graphql-tools/pull/640)
### v2.22.0
* When concatenating errors maintain a reference to the original for use downstream [Issue #480](https://github.com/apollographql/graphql-tools/issues/480) [PR #637](https://github.com/apollographql/graphql-tools/pull/637)
* Improve generic typings for several resolver-related interfaces [PR #662](https://github.com/apollographql/graphql-tools/pull/662)
* Remove copied apollo-link code [PR #670](https://github.com/apollographql/graphql-tools/pull/670)
* Handle undefined path in `getErrorsFromParent` [PR #667](https://github.com/apollographql/graphql-tools/pull/667)
### v2.21.0
* Make iterall a runtime dependency [PR #627](https://github.com/apollographql/graphql-tools/pull/627)
* Added support for lexical parser options [PR #567](https://github.com/apollographql/graphql-tools/pull/567)
* Support `graphql@^0.13.0` [PR #567](https://github.com/apollographql/graphql-tools/pull/567)
* Don't use `Symbol` in incompatible envs [Issue #535](https://github.com/apollographql/graphql-tools/issues/535) [PR #631](https://github.com/apollographql/graphql-tools/pull/631)
### v2.20.2
* Pass through apollo-link-http errors to originalError [PR #621](https://github.com/apollographql/graphql-tools/pull/621)
### v2.20.1
* Fix `error.path` could be `undefined` for schema stitching [PR #617](https://github.com/apollographql/graphql-tools/pull/617)
### v2.20.0
* Recreate enums and scalars for more consistent behaviour of merged schemas [PR #613](https://github.com/apollographql/graphql-tools/pull/613)
* `makeExecutableSchema` and `mergeSchema` now accept an array of `IResolver` [PR #612](https://github.com/apollographql/graphql-tools/pull/612) [PR #576](https://github.com/apollographql/graphql-tools/pull/576) [PR #577](https://github.com/apollographql/graphql-tools/pull/577)
* Fix `delegateToSchema.ts` to remove duplicate new variable definitions when delegating to schemas [PR #607](https://github.com/apollographql/graphql-tools/pull/607)
* Fix duplicate subscriptions for schema stitching [PR #609](https://github.com/apollographql/graphql-tools/pull/609)
### v2.19.0
* Also recreate `astNode` property for fields, not only types, when recreating schemas. [PR #580](https://github.com/apollographql/graphql-tools/pull/580)
* Fix `delegateToSchema.js` to accept and move forward args with zero or false values [PR #586](https://github.com/apollographql/graphql-tools/pull/586)
### v2.18.0
* Fix a bug where inline fragments got filtered in merged schemas when a type implemented multiple interfaces [PR #546](https://github.com/apollographql/graphql-tools/pull/546)
* IEnumResolver value can be a `number` type [PR #568](https://github.com/apollographql/graphql-tools/pull/568)
### v2.17.0
* Include `astNode` property in schema recreation [PR #569](https://github.com/apollographql/graphql-tools/pull/569)
### v2.16.0
* Added GraphQL Subscriptions support for schema stitching and `makeRemoteExecutableSchema` [PR #563](https://github.com/apollographql/graphql-tools/pull/563)
* Make `apollo-link` a direct dependency [PR #561](https://github.com/apollographql/graphql-tools/pull/561)
* Update tests to use `graphql-js@0.12` docstring format [PR #559](https://github.com/apollographql/graphql-tools/pull/559)
### v2.15.0
* Validate query before delegation [PR #551](https://github.com/apollographql/graphql-tools/pull/551)
### v2.14.1
* Add guard against invalid schemas being constructed from AST [PR #547](https://github.com/apollographql/graphql-tools/pull/547)
### v2.14.0
Update to add support for `graphql@0.12`, and drop versions before `0.11` from the peer dependencies list. The `graphql` package has some breaking changes you might need to be aware of, but there aren't any breaking changes in `graphql-tools` itself, or common usage patterns, so we are shipping this as a minor version. We're also running tests on this package with _both_ `graphql@0.11` and `graphql@0.12` until we confirm most users have updated.
* Visit the [`graphql` releases page](https://github.com/graphql/graphql-js/releases) to keep track of for breaking changes to the underlying package.
* [PR #541](https://github.com/apollographql/graphql-tools/pull/541)
### v2.13.0
* (Experimental) Added support for custom directives on FIELD_DEFINITION that wrap resolvers with custom reusable logic. [Issue #212](https://github.com/apollographql/graphql-tools/issues/212) [PR #518](https://github.com/apollographql/graphql-tools/pull/518) and [PR #529](https://github.com/apollographql/graphql-tools/pull/529)
### v2.12.0
* Allow passing in a string `schema` to `makeRemoteExecutableSchema` [PR #521](https://github.com/apollographql/graphql-tools/pull/521)
### v2.11.0
* Merge schema now can accept resolvers in a plain object format, mergeInfo added to GraphQLResolveInfo object in merged schema resolvers [PR #511](https://github.com/apollographql/graphql-tools/pull/511)
### v2.10.0
* Added basic support for custom Enums [Issue #363](https://github.com/apollographql/graphql-tools/issues/363) [PR #507](https://github.com/apollographql/graphql-tools/pull/507) [Read the docs here](https://www.apollographql.com/docs/graphql-tools/scalars.html#enums)
### v2.9.0
* Added basic subscription support for local schemas [Issue #420](https://github.com/apollographql/graphql-tools/issues/420) [PR #463](https://github.com/apollographql/graphql-tools/pull/463)
* Fix input object default value not propagating to merged schema [Issue #497](https://github.com/apollographql/graphql-tools/issues/497) [PR #498](PR #463](https://github.com/apollographql/graphql-tools/pull/498)
### v2.8.0
* Add the option `resolverValidationOptions.allowResolversNotInSchema` to allow resolvers to be set even when they are not defined in the schemas [PR #444](https://github.com/apollographql/graphql-tools/pull/444)
* Fix schema stitching bug when aliases are used with union types and fragments [PR #482](https://github.com/apollographql/graphql-tools/pull/482)
* Remove `isTypeOf` guards from merged schemas [PR #484](https://github.com/apollographql/graphql-tools/pull/484)
### v2.7.2
* Incompatible fragments are now properly filtered [PR #470](https://github.com/apollographql/graphql-tools/pull/470)
### v2.7.1
* Made `resolvers` parameter optional for `mergeSchemas` [Issue #461](https://github.com/apollographql/graphql-tools/issues/461) [PR #462](https://github.com/apollographql/graphql-tools/pull/462)
* Make it possible to define interfaces in schema extensions [PR #464](https://github.com/apollographql/graphql-tools/pull/464)
### v2.7.0
* Upgraded versions of dependencies
### v2.6.1
* Fix one place where `apollo-link` was being used directly
### v2.6.0
* Removed direct dependency on Apollo Link, while keeping the API the same, to work around a Launchpad npm installation issue temporarily.
* Parse type, field, and argument descriptions in `typeFromAST`. This allows the
descriptions to be part of the schema when using helpers like `mergeSchemas()`.
### v2.5.0
* Add ability to pass types in extension strings [Issue #427](https://github.com/apollographql/graphql-tools/issues/427) [PR #430](https://github.com/apollographql/graphql-tools/pull/430)
### v2.4.0
* Translate errors better in merged schema [Issue #419](https://github.com/apollographql/graphql-tools/issues/419) [PR #425](https://github.com/apollographql/graphql-tools/pull/425)
### v2.3.0
* Fix alias issues [Issue #415](https://github.com/apollographql/graphql-tools/issues/415) [PR #418](https://github.com/apollographql/graphql-tools/pull/418)
* Make `@types/graphql` a dev dependency and make it's version as flexible as `graphql` [PR #421](https://github.com/apollographql/graphql-tools/pull/421)
### v2.2.1
* Fix inability to add recursive queries [PR #413](https://github.com/apollographql/graphql-tools/pull/413)
### v2.2.0
* Change link API to pass GraphQL context as `graphqlContext` field of link
context to avoid merging problems
* Fix alias problems in schema merging [PR #411](https://github.com/apollographql/graphql-tools/pull/411)
### v2.1.0
* Added support for passing an Apollo Link instead of a fetcher
### v2.0.0
* Add schema merging utilities [PR #382](https://github.com/apollographql/graphql-tools/pull/382)
### v1.2.3
* Update package.json to allow GraphQL.js 0.11 [Issue #394](https://github.com/apollographql/graphql-tools/issues/394) [PR #395](https://github.com/apollographql/graphql-tools/pull/395)
### v1.2.1
* Fix typings for resolver options: [Issue #372](https://github.com/apollographql/graphql-tools/issues/372) [PR #374](https://github.com/apollographql/graphql-tools/pull/374)
### v.1.2.0
* Use defaultFieldResolver from graphql-js package instead of own one [PR #373](https://github.com/apollographql/graphql-tools/pull/373)
* Remove `lodash` dependency [PR #356](https://github.com/apollographql/graphql-tools/pull/356)
### v.1.1.0
* Improve mocking of union and interface types [PR #332](https://github.com/apollographql/graphql-tools/pull/332)
### v1.0.0
* Add argument validation in `addMockFunctionsToSchema` for 'schema' property in parameter object [PR #321](https://github.com/apollographql/graphql-tools/pull/321)
### v0.11.0
* Remove dependency on `graphql-subscription` and use an interface for PubSub [PR #295](https://github.com/apollographql/graphql-tools/pull/295)
* Support schema AST as a type definition input [PR #300](https://github.com/apollographql/graphql-tools/pull/300)
* Update graphql typings to 0.9.0 [PR #298](https://github.com/apollographql/graphql-tools/pull/298)
### v0.10.1
* Update dependencies [PR #287](https://github.com/apollographql/graphql-tools/pull/287)
### v0.10.0
* Restrict version range of graphql-js peer dependency to ^0.8.0 || ^0.9.0 [PR #266](https://github.com/apollographql/graphql-tools/pull/266)
### v0.9.2
* Update graphql-js dependency to include 0.9.0 [PR #264](https://github.com/apollostack/graphql-tools/pull/264)
* Fix logErrors option so it logs errors if resolve function returns a promise [PR #262](https://github.com/apollostack/graphql-tools/pull/262)
### v0.9.1
* use function reference instead of string for concatenateTypeDefs. [PR #252](https://github.com/apollostack/graphql-tools/pull/252)
### v0.9.0
* Migrate from `typed-graphql` to `@types/graphql`. [PR #249](https://github.com/apollostack/graphql-tools/pull/249)
### v0.8.4
* `addSchemaLevelResolveFunction` resolves once per operation type and not once globally. [#220](https://github.com/apollostack/graphql-tools/pull/220)
* Replace node-uuid with uuid package [#227](https://github.com/apollostack/graphql-tools/pull/227)
* Fix issue that prevented usage of custom scalars as arguments [#224](https://github.com/apollostack/graphql-tools/pull/224)
### v0.8.3
* Remove peer dependency on `graphql-subscriptions`. [#210](https://github.com/apollostack/graphql-tools/pull/210)
### v0.8.2
* Accept an async function for the schema level resolver. ([@ephemer](https://github.com/ephemer) in [#199](https://github.com/apollostack/graphql-tools/pull/199))
* Fix for new custom scalar support introduced in `0.8.1`. ([@oricordeau](https://github.com/oricordeau) in [#203](https://github.com/apollostack/graphql-tools/pull/203))
### v0.8.1
* Support custom scalar types developed for GraphQL.js, such as [graphql-type-json](https://github.com/taion/graphql-type-json). ([@oricordeau](https://github.com/oricordeau) in [#189](https://github.com/apollostack/graphql-tools/pull/189))
### v0.8.0
* Update default resolve function to match the one from GraphQL.js ([@stubailo](https://github.com/stubailo) in [#183](https://github.com/apollostack/graphql-tools/pull/183))
* Move `typed-graphql` to `optionalDependencies` ([@stubailo](https://github.com/stubailo) in [#183](https://github.com/apollostack/graphql-tools/pull/183))
* Set new defaults for resolver validation to match GraphQL.js so that developers need to opt-in to advanced validation ([@stubailo](https://github.com/stubailo) in [#183](https://github.com/apollostack/graphql-tools/pull/183)):
* `requireResolversForArgs = false` \* `requireResolversForNonScalar = false`
### v0.7.2
* Eliminated babel and moved to native ES5 compilation. ([@DxCx](https://github.com/DxCx) in [#147](https://github.com/apollostack/graphql-tools/pull/147))
### v0.7.1
* Fix dependency on lodash
### v0.7.0
* Various Bugfixes ([@DxCx](https://github.com/DxCx) in [#129](https://github.com/apollostack/graphql-tools/pull/129)) - Istanbul coverage was not working well due to Istanbul bug [#549](https://github.com/gotwarlost/istanbul/issues/549) - Bluebird promise was not converted well on tests - "console.warn" got overwritten on tests
* Migrated code from Javascript to Typescript ([@DxCx](https://github.com/DxCx) in [#129](https://github.com/apollostack/graphql-tools/pull/129))
* Deprecated addConnectorsToContext ([@DxCx](https://github.com/DxCx) in [#129](https://github.com/apollostack/graphql-tools/pull/129))
* Removed deprecated aplloServer ([@DxCx](https://github.com/DxCx) in [#129](https://github.com/apollostack/graphql-tools/pull/129))
* Removed testing on Node 5 ([@DxCx](https://github.com/DxCx) in [#129](https://github.com/apollostack/graphql-tools/pull/129))
* Changed GraphQL typings requirement from peer to standard ([@DxCx](https://github.com/DxCx) in [#129](https://github.com/apollostack/graphql-tools/pull/129))
* Change the missing resolve function validator to show a warning instead of an error ([@nicolaslopezj](https://github.com/nicolaslopezj) in [#134](https://github.com/apollostack/graphql-tools/pull/134))
* Add missing type annotations to avoid typescript compiler errors when 'noImplicitAny' is enabled ([@almilo](https://github.com/almilo) in [#133](https://github.com/apollostack/graphql-tools/pull/133))
### v0.6.6
* Added embedded Typescript definitions ([@DxCx](https://github.com/DxCx) in [#120](https://github.com/apollostack/graphql-tools/pull/120))
* Fix issue in addMockFunctionsToSchema when preserveResolvers is true and connector/logger is used. ([@DxCx](https://github.com/DxCx) in [#121](https://github.com/apollostack/graphql-tools/pull/121))
* Fix multiple issues in addMockFunctionsToSchema when preserveResolvers is true (support for Promises, and props defined using Object.defineProperty) ([@sebastienbarre](https://github.com/sebastienbarre) in [#115](https://github.com/apollostack/graphql-tools/pull/115))
* Make allowUndefinedInResolve true by default ([@jbaxleyiii](https://github.com/jbaxleyiii) in [#117](https://github.com/apollostack/graphql-tools/pull/117))
* Add `requireResolversForAllFields` resolver validation option ([@nevir](https://github.com/nevir) in [#107](https://github.com/apollostack/graphql-tools/pull/107))
### v0.6.4
* Make mocking partial objects match expected behavior ([@sebastienbarre](https://github.com/sebastienbarre) in [#96](https://github.com/apollostack/graphql-tools/pull/96))
* Improved behavior when mocking interfaces & unions ([@itajaja](https://github.com/itajaja) in [#102](https://github.com/apollostack/graphql-tools/pull/102))
### v0.6.3
* Unpin babel-core version to solve build problem (PR [#92](https://github.com/apollographql/graphql-tools/pull/92))
* Added support for `extend` keyword to schemaGenerator (PR [#90](https://github.com/apollostack/graphql-tools/pull/90))
### v0.6.2
* Fix a bug with addSchemaLevelResolveFunction. It now runs once per tick (PR [#91](https://github.com/apollographql/graphql-tools/pull/91))
### v0.5.2
* Add addSchemaLevelResolveFunction to exports
* Remove dist folder before prepublish to make sure files deleted in source are not included in build
### v0.5.1
* Updated GraphQL dependency to 0.6.0
* Removed all tracer code, including `Tracer`, `addTracingToResolvers` and `decorateWithTracer`

82
node_modules/graphql-tools/CONTRIBUTING.md generated vendored Normal file
View File

@@ -0,0 +1,82 @@
# Apollo Contributor Guide
Excited about Apollo and want to make it better? We’re excited too!
Apollo is a community of developers just like you, striving to create the best tools and libraries around GraphQL. We welcome anyone who wants to contribute or provide constructive feedback, no matter the age or level of experience. If you want to help but don't know where to start, let us know, and we'll find something for you.
Oh, and if you haven't already, sign up for the [Apollo Slack](http://www.apollodata.com/#slack).
Here are some ways to contribute to the project, from easiest to most difficult:
* [Reporting bugs](#reporting-bugs)
* [Improving the documentation](#improving-the-documentation)
* [Responding to issues](#responding-to-issues)
* [Small bug fixes](#small-bug-fixes)
* [Suggesting features](#suggesting-features)
* [Big pull requests](#big-prs)
## Issues
### Reporting bugs
If you encounter a bug, please file an issue on GitHub via the repository of the sub-project you think contains the bug. If an issue you have is already reported, please add additional information or add a 👍 reaction to indicate your agreement.
While we will try to be as helpful as we can on any issue reported, please include the following to maximize the chances of a quick fix:
1. **Intended outcome:** What you were trying to accomplish when the bug occurred, and as much code as possible related to the source of the problem.
2. **Actual outcome:** A description of what actually happened, including a screenshot or copy-paste of any related error messages, logs, or other output that might be related. Places to look for information include your browser console, server console, and network logs. Please avoid non-specific phrases like “didn’t work” or “broke”.
3. **How to reproduce the issue:** Instructions for how the issue can be reproduced by a maintainer or contributor. Be as specific as possible, and only mention what is necessary to reproduce the bug. If possible, try to isolate the exact circumstances in which the bug occurs and avoid speculation over what the cause might be.
Creating a good reproduction really helps contributors investigate and resolve your issue quickly. In many cases, the act of creating a minimal reproduction illuminates that the source of the bug was somewhere outside the library in question, saving time and effort for everyone.
### Improving the documentation
Improving the documentation, examples, and other open source content can be the easiest way to contribute to the library. If you see a piece of content that can be better, open a PR with an improvement, no matter how small! If you would like to suggest a big change or major rewrite, we’d love to hear your ideas but please open an issue for discussion before writing the PR.
### Responding to issues
In addition to reporting issues, a great way to contribute to Apollo is to respond to other peoples' issues and try to identify the problem or help them work around it. If you’re interested in taking a more active role in this process, please go ahead and respond to issues. And don't forget to say "Hi" on Apollo Slack!
### Small bug fixes
For a small bug fix change (less than 20 lines of code changed), feel free to open a pull request. We’ll try to merge it as fast as possible and ideally publish a new release on the same day. The only requirement is, make sure you also add a test that verifies the bug you are trying to fix.
### Suggesting features
Most of the features in Apollo came from suggestions by you, the community! We welcome any ideas about how to make Apollo better for your use case. Unless there is overwhelming demand for a feature, it might not get implemented immediately, but please include as much information as possible that will help people have a discussion about your proposal:
1. **Use case:** What are you trying to accomplish, in specific terms? Often, there might already be a good way to do what you need and a new feature is unnecessary, but it’s hard to know without information about the specific use case.
2. **Could this be a plugin?** In many cases, a feature might be too niche to be included in the core of a library, and is better implemented as a companion package. If there isn’t a way to extend the library to do what you want, could we add additional plugin APIs? It’s important to make the case for why a feature should be part of the core functionality of the library.
3. **Is there a workaround?** Is this a more convenient way to do something that is already possible, or is there some blocker that makes a workaround unfeasible?
Feature requests will be labeled as such, and we encourage using GitHub issues as a place to discuss new features and possible implementation designs. Please refrain from submitting a pull request to implement a proposed feature until there is consensus that it should be included. This way, you can avoid putting in work that can’t be merged in.
Once there is a consensus on the need for a new feature, proceed as listed below under “Big PRs”.
## Big PRs
This includes:
- Big bug fixes
- New features
For significant changes to a repository, it’s important to settle on a design before starting on the implementation. This way, we can make sure that major improvements get the care and attention they deserve. Since big changes can be risky and might not always get merged, it’s good to reduce the amount of possible wasted effort by agreeing on an implementation design/plan first.
1. **Open an issue.** Open an issue about your bug or feature, as described above.
2. **Reach consensus.** Some contributors and community members should reach an agreement that this feature or bug is important, and that someone should work on implementing or fixing it.
3. **Agree on intended behavior.** On the issue, reach an agreement about the desired behavior. In the case of a bug fix, it should be clear what it means for the bug to be fixed, and in the case of a feature, it should be clear what it will be like for developers to use the new feature.
4. **Agree on implementation plan.** Write a plan for how this feature or bug fix should be implemented. What modules need to be added or rewritten? Should this be one pull request or multiple incremental improvements? Who is going to do each part?
5. **Submit PR.** In the case where multiple dependent patches need to be made to implement the change, only submit one at a time. Otherwise, the others might get stale while the first is reviewed and merged. Make sure to avoid “while we’re here” type changes - if something isn’t relevant to the improvement at hand, it should be in a separate PR; this especially includes code style changes of unrelated code.
6. **Review.** At least one core contributor should sign off on the change before it’s merged. Look at the “code review” section below to learn about factors are important in the code review. If you want to expedite the code being merged, try to review your own code first!
7. **Merge and release!**
### Code review guidelines
It’s important that every piece of code in Apollo packages is reviewed by at least one core contributor familiar with that codebase. Here are some things we look for:
1. **Required CI checks pass.** This is a prerequisite for the review, and it is the PR author's responsibility. As long as the tests don’t pass, the PR won't get reviewed.
2. **Simplicity.** Is this the simplest way to achieve the intended goal? If there are too many files, redundant functions, or complex lines of code, suggest a simpler way to do the same thing. In particular, avoid implementing an overly general solution when a simple, small, and pragmatic fix will do.
3. **Testing.** Do the tests ensure this code won’t break when other stuff changes around it? When it does break, will the tests added help us identify which part of the library has the problem? Did we cover an appropriate set of edge cases? Look at the test coverage report if there is one. Are all significant code paths in the new code exercised at least once?
4. **No unnecessary or unrelated changes.** PRs shouldn’t come with random formatting changes, especially in unrelated parts of the code. If there is some refactoring that needs to be done, it should be in a separate PR from a bug fix or feature, if possible.
5. **Code has appropriate comments.** Code should be commented, or written in a clear “self-documenting” way.
6. **Idiomatic use of the language.** In TypeScript, make sure the typings are specific and correct. In ES2015, make sure to use imports rather than require and const instead of var, etc. Ideally a linter enforces a lot of this, but use your common sense and follow the style of the surrounding code.

21
node_modules/graphql-tools/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,21 @@
The MIT License (MIT)
Copyright (c) 2015 - 2017 Meteor Development Group, Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

125
node_modules/graphql-tools/README.md generated vendored Normal file
View File

@@ -0,0 +1,125 @@
# GraphQL-tools: generate and mock GraphQL.js schemas
[![npm version](https://badge.fury.io/js/graphql-tools.svg)](https://badge.fury.io/js/graphql-tools)
[![Build Status](https://travis-ci.org/apollographql/graphql-tools.svg?branch=master)](https://travis-ci.org/apollographql/graphql-tools)
[![Coverage Status](https://coveralls.io/repos/github/apollographql/graphql-tools/badge.svg?branch=master)](https://coveralls.io/github/apollographql/graphql-tools?branch=master)
[![Get on Slack](https://img.shields.io/badge/slack-join-orange.svg)](http://www.apollostack.com/#slack)
This package provides a few useful ways to create a GraphQL schema:
1. Use the GraphQL schema language to [generate a schema](https://www.apollographql.com/docs/graphql-tools/generate-schema.html) with full support for resolvers, interfaces, unions, and custom scalars. The schema produced is completely compatible with [GraphQL.js](https://github.com/graphql/graphql-js).
2. [Mock your GraphQL API](https://www.apollographql.com/docs/graphql-tools/mocking.html) with fine-grained per-type mocking
3. Automatically [stitch multiple schemas together](https://www.apollographql.com/docs/graphql-tools/schema-stitching.html) into one larger API
## Documentation
[Read the docs.](https://www.apollographql.com/docs/graphql-tools/)
## Binding to HTTP
If you want to bind your JavaScript GraphQL schema to an HTTP server, we recommend using [Apollo Server](https://github.com/apollographql/apollo-server/), which supports every popular Node HTTP server library including Express, Koa, Hapi, and more.
JavaScript GraphQL servers are often developed with `graphql-tools` and `apollo-server-express` together: One to write the schema and resolver code, and the other to connect it to a web server.
## Example
When using `graphql-tools`, you describe the schema as a GraphQL type language string:
```js
const typeDefs = `
type Author {
id: ID! # the ! means that every author object _must_ have an id
firstName: String
lastName: String
"""
the list of Posts by this author
"""
posts: [Post]
}
type Post {
id: ID!
title: String
author: Author
votes: Int
}
# the schema allows the following query:
type Query {
posts: [Post]
}
# this schema allows the following mutation:
type Mutation {
upvotePost (
postId: ID!
): Post
}
# we need to tell the server which types represent the root query
# and root mutation types. We call them RootQuery and RootMutation by convention.
schema {
query: Query
mutation: Mutation
}
`;
export default typeDefs;
```
Then you define resolvers as a nested object that maps type and field names to resolver functions:
```js
const resolvers = {
Query: {
posts() {
return posts;
},
},
Mutation: {
upvotePost(_, { postId }) {
const post = find(posts, { id: postId });
if (!post) {
throw new Error(`Couldn't find post with id ${postId}`);
}
post.votes += 1;
return post;
},
},
Author: {
posts(author) {
return filter(posts, { authorId: author.id });
},
},
Post: {
author(post) {
return find(authors, { id: post.authorId });
},
},
};
export default resolvers;
```
At the end, the schema and resolvers are combined using `makeExecutableSchema`:
```js
import { makeExecutableSchema } from 'graphql-tools';
const executableSchema = makeExecutableSchema({
typeDefs,
resolvers,
});
```
This example has the entire type definition in one string and all resolvers in one file, but you can combine types and resolvers from multiple files and objects, as documented in the [modularizing the schema](https://www.apollographql.com/docs/graphql-tools/generate-schema.html#modularizing) section of the docs.
## Contributions
Contributions, issues and feature requests are very welcome. If you are using this package and fixed a bug for yourself, please consider submitting a PR!
## Maintainers
- [@hwillson](https://github.com/hwillson) (Apollo)
- [@benjamn](https://github.com/benjamn) (Apollo)

146
node_modules/graphql-tools/dist/Interfaces.d.ts generated vendored Normal file
View File

@@ -0,0 +1,146 @@
import { GraphQLSchema, GraphQLField, ExecutionResult, GraphQLType, GraphQLFieldResolver, GraphQLResolveInfo, GraphQLIsTypeOfFn, GraphQLTypeResolver, GraphQLScalarType, GraphQLNamedType, DocumentNode, ASTNode } from 'graphql';
import { SchemaDirectiveVisitor } from './schemaVisitor';
export declare type UnitOrList<Type> = Type | Array<Type>;
export interface IResolverValidationOptions {
requireResolversForArgs?: boolean;
requireResolversForNonScalar?: boolean;
requireResolversForAllFields?: boolean;
requireResolversForResolveType?: boolean;
allowResolversNotInSchema?: boolean;
}
export interface IAddResolveFunctionsToSchemaOptions {
schema: GraphQLSchema;
resolvers: IResolvers;
resolverValidationOptions?: IResolverValidationOptions;
inheritResolversFromInterfaces?: boolean;
}
export interface IResolverOptions<TSource = any, TContext = any, TArgs = any> {
fragment?: string;
resolve?: IFieldResolver<TSource, TContext, TArgs>;
subscribe?: IFieldResolver<TSource, TContext, TArgs>;
__resolveType?: GraphQLTypeResolver<TSource, TContext>;
__isTypeOf?: GraphQLIsTypeOfFn<TSource, TContext>;
}
export declare type Transform = {
transformSchema?: (schema: GraphQLSchema) => GraphQLSchema;
transformRequest?: (originalRequest: Request) => Request;
transformResult?: (result: Result) => Result;
};
export interface IGraphQLToolsResolveInfo extends GraphQLResolveInfo {
mergeInfo?: MergeInfo;
}
export interface IDelegateToSchemaOptions<TContext = {
[key: string]: any;
}> {
schema: GraphQLSchema;
operation: Operation;
fieldName: string;
args?: {
[key: string]: any;
};
context: TContext;
info: IGraphQLToolsResolveInfo;
transforms?: Array<Transform>;
skipValidation?: boolean;
}
export declare type MergeInfo = {
delegate: (type: 'query' | 'mutation' | 'subscription', fieldName: string, args: {
[key: string]: any;
}, context: {
[key: string]: any;
}, info: GraphQLResolveInfo, transforms?: Array<Transform>) => any;
delegateToSchema<TContext>(options: IDelegateToSchemaOptions<TContext>): any;
fragments: Array<{
field: string;
fragment: string;
}>;
};
export declare type IFieldResolver<TSource, TContext, TArgs = Record<string, any>> = (source: TSource, args: TArgs, context: TContext, info: GraphQLResolveInfo & {
mergeInfo: MergeInfo;
}) => any;
export declare type ITypedef = (() => ITypedef[]) | string | DocumentNode | ASTNode;
export declare type ITypeDefinitions = ITypedef | ITypedef[];
export declare type IResolverObject<TSource = any, TContext = any, TArgs = any> = {
[key: string]: IFieldResolver<TSource, TContext, TArgs> | IResolverOptions<TSource, TContext> | IResolverObject<TSource, TContext>;
};
export declare type IEnumResolver = {
[key: string]: string | number;
};
export interface IResolvers<TSource = any, TContext = any> {
[key: string]: (() => any) | IResolverObject<TSource, TContext> | IResolverOptions<TSource, TContext> | GraphQLScalarType | IEnumResolver;
}
export declare type IResolversParameter = Array<IResolvers | ((mergeInfo: MergeInfo) => IResolvers)> | IResolvers | ((mergeInfo: MergeInfo) => IResolvers);
export interface ILogger {
log: (message: string | Error) => void;
}
export interface IConnectorCls<TContext = any> {
new (context?: TContext): any;
}
export declare type IConnectorFn<TContext = any> = (context?: TContext) => any;
export declare type IConnector<TContext = any> = IConnectorCls<TContext> | IConnectorFn<TContext>;
export declare type IConnectors<TContext = any> = {
[key: string]: IConnector<TContext>;
};
export interface IExecutableSchemaDefinition<TContext = any> {
typeDefs: ITypeDefinitions;
resolvers?: IResolvers<any, TContext> | Array<IResolvers<any, TContext>>;
connectors?: IConnectors<TContext>;
logger?: ILogger;
allowUndefinedInResolve?: boolean;
resolverValidationOptions?: IResolverValidationOptions;
directiveResolvers?: IDirectiveResolvers<any, TContext>;
schemaDirectives?: {
[name: string]: typeof SchemaDirectiveVisitor;
};
parseOptions?: GraphQLParseOptions;
inheritResolversFromInterfaces?: boolean;
}
export declare type IFieldIteratorFn = (fieldDef: GraphQLField<any, any>, typeName: string, fieldName: string) => void;
export declare type NextResolverFn = () => Promise<any>;
export declare type DirectiveResolverFn<TSource = any, TContext = any> = (next: NextResolverFn, source: TSource, args: {
[argName: string]: any;
}, context: TContext, info: GraphQLResolveInfo) => any;
export interface IDirectiveResolvers<TSource = any, TContext = any> {
[directiveName: string]: DirectiveResolverFn<TSource, TContext>;
}
export declare type IMockFn = GraphQLFieldResolver<any, any>;
export declare type IMocks = {
[key: string]: IMockFn;
};
export declare type IMockTypeFn = (type: GraphQLType, typeName?: string, fieldName?: string) => GraphQLFieldResolver<any, any>;
export interface IMockOptions {
schema: GraphQLSchema;
mocks?: IMocks;
preserveResolvers?: boolean;
}
export interface IMockServer {
query: (query: string, vars?: {
[key: string]: any;
}) => Promise<ExecutionResult>;
}
export declare type MergeTypeCandidate = {
schema?: GraphQLSchema;
type: GraphQLNamedType;
};
export declare type TypeWithResolvers = {
type: GraphQLNamedType;
resolvers?: IResolvers;
};
export declare type VisitTypeResult = GraphQLNamedType | TypeWithResolvers | null;
export declare type VisitType = (name: string, candidates: Array<MergeTypeCandidate>) => VisitTypeResult;
export declare type Operation = 'query' | 'mutation' | 'subscription';
export declare type Request = {
document: DocumentNode;
variables: Record<string, any>;
extensions?: Record<string, any>;
};
export declare type Result = ExecutionResult & {
extensions?: Record<string, any>;
};
export declare type ResolveType<T extends GraphQLType> = (type: T) => T;
export declare type GraphQLParseOptions = {
noLocation?: boolean;
allowLegacySDLEmptyFields?: boolean;
allowLegacySDLImplementsInterfaces?: boolean;
experimentalFragmentVariables?: boolean;
};

2
node_modules/graphql-tools/dist/Interfaces.js generated vendored Normal file
View File

@@ -0,0 +1,2 @@
Object.defineProperty(exports, "__esModule", { value: true });
//# sourceMappingURL=Interfaces.js.map

1
node_modules/graphql-tools/dist/Interfaces.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"Interfaces.js","sourceRoot":"","sources":["../src/Interfaces.ts"],"names":[],"mappings":""}

10
node_modules/graphql-tools/dist/Logger.d.ts generated vendored Normal file
View File

@@ -0,0 +1,10 @@
import { ILogger } from './Interfaces';
export declare class Logger implements ILogger {
errors: Error[];
name: string;
private callback;
constructor(name?: string, callback?: Function);
log(err: Error): void;
printOneError(e: Error): string;
printAllErrors(): string;
}

28
node_modules/graphql-tools/dist/Logger.js generated vendored Normal file
View File

@@ -0,0 +1,28 @@
/*
* A very simple class for logging errors
*/
Object.defineProperty(exports, "__esModule", { value: true });
var Logger = /** @class */ (function () {
function Logger(name, callback) {
this.name = name;
this.errors = [];
this.callback = callback;
// TODO: should assert that callback is a function
}
Logger.prototype.log = function (err) {
this.errors.push(err);
if (typeof this.callback === 'function') {
this.callback(err);
}
};
Logger.prototype.printOneError = function (e) {
return e.stack;
};
Logger.prototype.printAllErrors = function () {
var _this = this;
return this.errors.reduce(function (agg, e) { return agg + "\n" + _this.printOneError(e); }, '');
};
return Logger;
}());
exports.Logger = Logger;
//# sourceMappingURL=Logger.js.map

1
node_modules/graphql-tools/dist/Logger.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"Logger.js","sourceRoot":"","sources":["../src/Logger.ts"],"names":[],"mappings":"AAAA;;GAEG;;AAIH;IAKE,gBAAY,IAAa,EAAE,QAAmB;QAC5C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;QACjB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,kDAAkD;IACpD,CAAC;IAEM,oBAAG,GAAV,UAAW,GAAU;QACnB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACtB,IAAI,OAAO,IAAI,CAAC,QAAQ,KAAK,UAAU,EAAE;YACvC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;SACpB;IACH,CAAC;IAEM,8BAAa,GAApB,UAAqB,CAAQ;QAC3B,OAAO,CAAC,CAAC,KAAK,CAAC;IACjB,CAAC;IAEM,+BAAc,GAArB;QAAA,iBAKC;QAJC,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CACvB,UAAC,GAAG,EAAE,CAAC,IAAK,OAAG,GAAG,UAAK,KAAI,CAAC,aAAa,CAAC,CAAC,CAAG,EAAlC,CAAkC,EAC9C,EAAE,CACH,CAAC;IACJ,CAAC;IACH,aAAC;AAAD,CAAC,AA7BD,IA6BC;AA7BY,wBAAM"}

4
node_modules/graphql-tools/dist/generate/SchemaError.d.ts generated vendored Normal file
View File

@@ -0,0 +1,4 @@
export default class SchemaError extends Error {
message: string;
constructor(message: string);
}

28
node_modules/graphql-tools/dist/generate/SchemaError.js generated vendored Normal file
View File

@@ -0,0 +1,28 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
// @schemaDefinition: A GraphQL type schema in shorthand
// @resolvers: Definitions for resolvers to be merged with schema
var SchemaError = /** @class */ (function (_super) {
__extends(SchemaError, _super);
function SchemaError(message) {
var _this = _super.call(this, message) || this;
_this.message = message;
Error.captureStackTrace(_this, _this.constructor);
return _this;
}
return SchemaError;
}(Error));
exports.default = SchemaError;
//# sourceMappingURL=SchemaError.js.map

1
node_modules/graphql-tools/dist/generate/SchemaError.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"SchemaError.js","sourceRoot":"","sources":["../../src/generate/SchemaError.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,wDAAwD;AACxD,iEAAiE;AACjE;IAAyC,+BAAK;IAG5C,qBAAY,OAAe;QAA3B,YACE,kBAAM,OAAO,CAAC,SAGf;QAFC,KAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,KAAK,CAAC,iBAAiB,CAAC,KAAI,EAAE,KAAI,CAAC,WAAW,CAAC,CAAC;;IAClD,CAAC;IACH,kBAAC;AAAD,CAAC,AARD,CAAyC,KAAK,GAQ7C"}

4
node_modules/graphql-tools/dist/generate/addResolveFunctionsToSchema.d.ts generated vendored Normal file
View File

@@ -0,0 +1,4 @@
import { GraphQLSchema } from 'graphql';
import { IResolvers, IResolverValidationOptions, IAddResolveFunctionsToSchemaOptions } from '../Interfaces';
declare function addResolveFunctionsToSchema(options: IAddResolveFunctionsToSchemaOptions | GraphQLSchema, legacyInputResolvers?: IResolvers, legacyInputValidationOptions?: IResolverValidationOptions): GraphQLSchema;
export default addResolveFunctionsToSchema;

119
node_modules/graphql-tools/dist/generate/addResolveFunctionsToSchema.js generated vendored Normal file
View File

@@ -0,0 +1,119 @@
Object.defineProperty(exports, "__esModule", { value: true });
var _1 = require(".");
var graphql_1 = require("graphql");
var transforms_1 = require("../transforms/transforms");
var _2 = require(".");
var ConvertEnumValues_1 = require("../transforms/ConvertEnumValues");
function addResolveFunctionsToSchema(options, legacyInputResolvers, legacyInputValidationOptions) {
if (options instanceof graphql_1.GraphQLSchema) {
console.warn('The addResolveFunctionsToSchema function takes named options now; see IAddResolveFunctionsToSchemaOptions');
options = {
schema: options,
resolvers: legacyInputResolvers,
resolverValidationOptions: legacyInputValidationOptions,
};
}
var schema = options.schema, inputResolvers = options.resolvers, _a = options.resolverValidationOptions, resolverValidationOptions = _a === void 0 ? {} : _a, _b = options.inheritResolversFromInterfaces, inheritResolversFromInterfaces = _b === void 0 ? false : _b;
var _c = resolverValidationOptions.allowResolversNotInSchema, allowResolversNotInSchema = _c === void 0 ? false : _c, requireResolversForResolveType = resolverValidationOptions.requireResolversForResolveType;
var resolvers = inheritResolversFromInterfaces
? _2.extendResolversFromInterfaces(schema, inputResolvers)
: inputResolvers;
// Used to map the external value of an enum to its internal value, when
// that internal value is provided by a resolver.
var enumValueMap = Object.create(null);
Object.keys(resolvers).forEach(function (typeName) {
var resolverValue = resolvers[typeName];
var resolverType = typeof resolverValue;
if (resolverType !== 'object' && resolverType !== 'function') {
throw new _1.SchemaError("\"" + typeName + "\" defined in resolvers, but has invalid value \"" + resolverValue + "\". A resolver's value " +
"must be of type object or function.");
}
var type = schema.getType(typeName);
if (!type && typeName !== '__schema') {
if (allowResolversNotInSchema) {
return;
}
throw new _1.SchemaError("\"" + typeName + "\" defined in resolvers, but not in schema");
}
Object.keys(resolverValue).forEach(function (fieldName) {
if (fieldName.startsWith('__')) {
// this is for isTypeOf and resolveType and all the other stuff.
type[fieldName.substring(2)] = resolverValue[fieldName];
return;
}
if (type instanceof graphql_1.GraphQLScalarType) {
type[fieldName] = resolverValue[fieldName];
return;
}
if (type instanceof graphql_1.GraphQLEnumType) {
if (!type.getValue(fieldName)) {
if (allowResolversNotInSchema) {
return;
}
throw new _1.SchemaError(typeName + "." + fieldName + " was defined in resolvers, but enum is not in schema");
}
// We've encountered an enum resolver that is being used to provide an
// internal enum value.
// Reference: https://www.apollographql.com/docs/graphql-tools/scalars.html#internal-values
//
// We're storing a map of the current enums external facing value to
// its resolver provided internal value. This map is used to transform
// the current schema to a new schema that includes enums with the new
// internal value.
enumValueMap[type.name] = enumValueMap[type.name] || {};
enumValueMap[type.name][fieldName] = resolverValue[fieldName];
return;
}
// object type
var fields = getFieldsForType(type);
if (!fields) {
if (allowResolversNotInSchema) {
return;
}
throw new _1.SchemaError(typeName + " was defined in resolvers, but it's not an object");
}
if (!fields[fieldName]) {
if (allowResolversNotInSchema) {
return;
}
throw new _1.SchemaError(typeName + "." + fieldName + " defined in resolvers, but not in schema");
}
var field = fields[fieldName];
var fieldResolve = resolverValue[fieldName];
if (typeof fieldResolve === 'function') {
// for convenience. Allows shorter syntax in resolver definition file
setFieldProperties(field, { resolve: fieldResolve });
}
else {
if (typeof fieldResolve !== 'object') {
throw new _1.SchemaError("Resolver " + typeName + "." + fieldName + " must be object or function");
}
setFieldProperties(field, fieldResolve);
}
});
});
_2.checkForResolveTypeResolver(schema, requireResolversForResolveType);
// If there are any enum resolver functions (that are used to return
// internal enum values), create a new schema that includes enums with the
// new internal facing values.
var updatedSchema = transforms_1.applySchemaTransforms(schema, [
new ConvertEnumValues_1.default(enumValueMap),
]);
return updatedSchema;
}
function getFieldsForType(type) {
if (type instanceof graphql_1.GraphQLObjectType ||
type instanceof graphql_1.GraphQLInterfaceType) {
return type.getFields();
}
else {
return undefined;
}
}
function setFieldProperties(field, propertiesObj) {
Object.keys(propertiesObj).forEach(function (propertyName) {
field[propertyName] = propertiesObj[propertyName];
});
}
exports.default = addResolveFunctionsToSchema;
//# sourceMappingURL=addResolveFunctionsToSchema.js.map

1
node_modules/graphql-tools/dist/generate/addResolveFunctionsToSchema.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"addResolveFunctionsToSchema.js","sourceRoot":"","sources":["../../src/generate/addResolveFunctionsToSchema.ts"],"names":[],"mappings":"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"}

3
node_modules/graphql-tools/dist/generate/addSchemaLevelResolveFunction.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
import { GraphQLSchema, GraphQLFieldResolver } from 'graphql';
declare function addSchemaLevelResolveFunction(schema: GraphQLSchema, fn: GraphQLFieldResolver<any, any>): void;
export default addSchemaLevelResolveFunction;

61
node_modules/graphql-tools/dist/generate/addSchemaLevelResolveFunction.js generated vendored Normal file
View File

@@ -0,0 +1,61 @@
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
// wraps all resolve functions of query, mutation or subscription fields
// with the provided function to simulate a root schema level resolve funciton
function addSchemaLevelResolveFunction(schema, fn) {
// TODO test that schema is a schema, fn is a function
var rootTypes = [
schema.getQueryType(),
schema.getMutationType(),
schema.getSubscriptionType(),
].filter(function (x) { return !!x; });
rootTypes.forEach(function (type) {
// XXX this should run at most once per request to simulate a true root resolver
// for graphql-js this is an approximation that works with queries but not mutations
var rootResolveFn = runAtMostOncePerRequest(fn);
var fields = type.getFields();
Object.keys(fields).forEach(function (fieldName) {
// XXX if the type is a subscription, a same query AST will be ran multiple times so we
// deactivate here the runOnce if it's a subscription. This may not be optimal though...
if (type === schema.getSubscriptionType()) {
fields[fieldName].resolve = wrapResolver(fields[fieldName].resolve, fn);
}
else {
fields[fieldName].resolve = wrapResolver(fields[fieldName].resolve, rootResolveFn);
}
});
});
}
// XXX badly named function. this doesn't really wrap, it just chains resolvers...
function wrapResolver(innerResolver, outerResolver) {
return function (obj, args, ctx, info) {
return Promise.resolve(outerResolver(obj, args, ctx, info)).then(function (root) {
if (innerResolver) {
return innerResolver(root, args, ctx, info);
}
return graphql_1.defaultFieldResolver(root, args, ctx, info);
});
};
}
// XXX this function only works for resolvers
// XXX very hacky way to remember if the function
// already ran for this request. This will only work
// if people don't actually cache the operation.
// if they do cache the operation, they will have to
// manually remove the __runAtMostOnce before every request.
function runAtMostOncePerRequest(fn) {
var value;
var randomNumber = Math.random();
return function (root, args, ctx, info) {
if (!info.operation['__runAtMostOnce']) {
info.operation['__runAtMostOnce'] = {};
}
if (!info.operation['__runAtMostOnce'][randomNumber]) {
info.operation['__runAtMostOnce'][randomNumber] = true;
value = fn(root, args, ctx, info);
}
return value;
};
}
exports.default = addSchemaLevelResolveFunction;
//# sourceMappingURL=addSchemaLevelResolveFunction.js.map

1
node_modules/graphql-tools/dist/generate/addSchemaLevelResolveFunction.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"addSchemaLevelResolveFunction.js","sourceRoot":"","sources":["../../src/generate/addSchemaLevelResolveFunction.ts"],"names":[],"mappings":";AAAA,mCAIiB;AAEjB,wEAAwE;AACxE,8EAA8E;AAC9E,SAAS,6BAA6B,CACpC,MAAqB,EACrB,EAAkC;IAElC,sDAAsD;IACtD,IAAM,SAAS,GAAG;QAChB,MAAM,CAAC,YAAY,EAAE;QACrB,MAAM,CAAC,eAAe,EAAE;QACxB,MAAM,CAAC,mBAAmB,EAAE;KAC7B,CAAC,MAAM,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,CAAC,EAAH,CAAG,CAAC,CAAC;IACnB,SAAS,CAAC,OAAO,CAAC,UAAA,IAAI;QACpB,gFAAgF;QAChF,oFAAoF;QACpF,IAAM,aAAa,GAAG,uBAAuB,CAAC,EAAE,CAAC,CAAC;QAClD,IAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAChC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,UAAA,SAAS;YACnC,uFAAuF;YACvF,wFAAwF;YACxF,IAAI,IAAI,KAAK,MAAM,CAAC,mBAAmB,EAAE,EAAE;gBACzC,MAAM,CAAC,SAAS,CAAC,CAAC,OAAO,GAAG,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;aACzE;iBAAM;gBACL,MAAM,CAAC,SAAS,CAAC,CAAC,OAAO,GAAG,YAAY,CACtC,MAAM,CAAC,SAAS,CAAC,CAAC,OAAO,EACzB,aAAa,CACd,CAAC;aACH;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED,kFAAkF;AAClF,SAAS,YAAY,CACnB,aAAyD,EACzD,aAA6C;IAE7C,OAAO,UAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI;QAC1B,OAAO,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,UAAA,IAAI;YACnE,IAAI,aAAa,EAAE;gBACjB,OAAO,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;aAC7C;YACD,OAAO,8BAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAED,6CAA6C;AAC7C,iDAAiD;AACjD,oDAAoD;AACpD,gDAAgD;AAChD,oDAAoD;AACpD,4DAA4D;AAC5D,SAAS,uBAAuB,CAC9B,EAAkC;IAElC,IAAI,KAAU,CAAC;IACf,IAAM,YAAY,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;IACnC,OAAO,UAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI;QAC3B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,EAAE;YACtC,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAAC;SACxC;QACD,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC,YAAY,CAAC,EAAE;YACpD,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;YACvD,KAAK,GAAG,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;SACnC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;AACJ,CAAC;AAED,kBAAe,6BAA6B,CAAC"}

4
node_modules/graphql-tools/dist/generate/assertResolveFunctionsPresent.d.ts generated vendored Normal file
View File

@@ -0,0 +1,4 @@
import { GraphQLSchema } from 'graphql';
import { IResolverValidationOptions } from '../Interfaces';
declare function assertResolveFunctionsPresent(schema: GraphQLSchema, resolverValidationOptions?: IResolverValidationOptions): void;
export default assertResolveFunctionsPresent;

41
node_modules/graphql-tools/dist/generate/assertResolveFunctionsPresent.js generated vendored Normal file
View File

@@ -0,0 +1,41 @@
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
var _1 = require(".");
function assertResolveFunctionsPresent(schema, resolverValidationOptions) {
if (resolverValidationOptions === void 0) { resolverValidationOptions = {}; }
var _a = resolverValidationOptions.requireResolversForArgs, requireResolversForArgs = _a === void 0 ? false : _a, _b = resolverValidationOptions.requireResolversForNonScalar, requireResolversForNonScalar = _b === void 0 ? false : _b, _c = resolverValidationOptions.requireResolversForAllFields, requireResolversForAllFields = _c === void 0 ? false : _c;
if (requireResolversForAllFields &&
(requireResolversForArgs || requireResolversForNonScalar)) {
throw new TypeError('requireResolversForAllFields takes precedence over the more specific assertions. ' +
'Please configure either requireResolversForAllFields or requireResolversForArgs / ' +
'requireResolversForNonScalar, but not a combination of them.');
}
_1.forEachField(schema, function (field, typeName, fieldName) {
// requires a resolve function for *every* field.
if (requireResolversForAllFields) {
expectResolveFunction(field, typeName, fieldName);
}
// requires a resolve function on every field that has arguments
if (requireResolversForArgs && field.args.length > 0) {
expectResolveFunction(field, typeName, fieldName);
}
// requires a resolve function on every field that returns a non-scalar type
if (requireResolversForNonScalar &&
!(graphql_1.getNamedType(field.type) instanceof graphql_1.GraphQLScalarType)) {
expectResolveFunction(field, typeName, fieldName);
}
});
}
function expectResolveFunction(field, typeName, fieldName) {
if (!field.resolve) {
console.warn(
// tslint:disable-next-line: max-line-length
"Resolve function missing for \"" + typeName + "." + fieldName + "\". To disable this warning check https://github.com/apollostack/graphql-tools/issues/131");
return;
}
if (typeof field.resolve !== 'function') {
throw new _1.SchemaError("Resolver \"" + typeName + "." + fieldName + "\" must be a function");
}
}
exports.default = assertResolveFunctionsPresent;
//# sourceMappingURL=assertResolveFunctionsPresent.js.map

1
node_modules/graphql-tools/dist/generate/assertResolveFunctionsPresent.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"assertResolveFunctionsPresent.js","sourceRoot":"","sources":["../../src/generate/assertResolveFunctionsPresent.ts"],"names":[],"mappings":";AAAA,mCAKiB;AAGjB,sBAA8C;AAE9C,SAAS,6BAA6B,CACpC,MAAqB,EACrB,yBAA0D;IAA1D,0CAAA,EAAA,8BAA0D;IAGxD,IAAA,sDAA+B,EAA/B,oDAA+B,EAC/B,2DAAoC,EAApC,yDAAoC,EACpC,2DAAoC,EAApC,yDAAoC,CACR;IAE9B,IACE,4BAA4B;QAC5B,CAAC,uBAAuB,IAAI,4BAA4B,CAAC,EACzD;QACA,MAAM,IAAI,SAAS,CACjB,mFAAmF;YACjF,oFAAoF;YACpF,8DAA8D,CACjE,CAAC;KACH;IAED,eAAY,CAAC,MAAM,EAAE,UAAC,KAAK,EAAE,QAAQ,EAAE,SAAS;QAC9C,iDAAiD;QACjD,IAAI,4BAA4B,EAAE;YAChC,qBAAqB,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;SACnD;QAED,gEAAgE;QAChE,IAAI,uBAAuB,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;YACpD,qBAAqB,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;SACnD;QAED,4EAA4E;QAC5E,IACE,4BAA4B;YAC5B,CAAC,CAAC,sBAAY,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,2BAAiB,CAAC,EACxD;YACA,qBAAqB,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;SACnD;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAS,qBAAqB,CAC5B,KAA6B,EAC7B,QAAgB,EAChB,SAAiB;IAEjB,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE;QAClB,OAAO,CAAC,IAAI;QACV,4CAA4C;QAC5C,oCAAiC,QAAQ,SAAI,SAAS,8FAA0F,CACjJ,CAAC;QACF,OAAO;KACR;IACD,IAAI,OAAO,KAAK,CAAC,OAAO,KAAK,UAAU,EAAE;QACvC,MAAM,IAAI,cAAW,CACnB,gBAAa,QAAQ,SAAI,SAAS,0BAAsB,CACzD,CAAC;KACH;AACH,CAAC;AAED,kBAAe,6BAA6B,CAAC"}

2
node_modules/graphql-tools/dist/generate/attachConnectorsToContext.d.ts generated vendored Normal file
View File

@@ -0,0 +1,2 @@
declare const attachConnectorsToContext: Function;
export default attachConnectorsToContext;

55
node_modules/graphql-tools/dist/generate/attachConnectorsToContext.js generated vendored Normal file
View File

@@ -0,0 +1,55 @@
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
var deprecated_decorator_1 = require("deprecated-decorator");
var _1 = require(".");
// takes a GraphQL-JS schema and an object of connectors, then attaches
// the connectors to the context by wrapping each query or mutation resolve
// function with a function that attaches connectors if they don't exist.
// attaches connectors only once to make sure they are singletons
var attachConnectorsToContext = deprecated_decorator_1.deprecated({
version: '0.7.0',
url: 'https://github.com/apollostack/graphql-tools/issues/140',
}, function (schema, connectors) {
if (!schema || !(schema instanceof graphql_1.GraphQLSchema)) {
throw new Error('schema must be an instance of GraphQLSchema. ' +
'This error could be caused by installing more than one version of GraphQL-JS');
}
if (typeof connectors !== 'object') {
var connectorType = typeof connectors;
throw new Error("Expected connectors to be of type object, got " + connectorType);
}
if (Object.keys(connectors).length === 0) {
throw new Error('Expected connectors to not be an empty object');
}
if (Array.isArray(connectors)) {
throw new Error('Expected connectors to be of type object, got Array');
}
if (schema['_apolloConnectorsAttached']) {
throw new Error('Connectors already attached to context, cannot attach more than once');
}
schema['_apolloConnectorsAttached'] = true;
var attachconnectorFn = function (root, args, ctx) {
if (typeof ctx !== 'object') {
// if in any way possible, we should throw an error when the attachconnectors
// function is called, not when a query is executed.
var contextType = typeof ctx;
throw new Error("Cannot attach connector because context is not an object: " + contextType);
}
if (typeof ctx.connectors === 'undefined') {
ctx.connectors = {};
}
Object.keys(connectors).forEach(function (connectorName) {
var connector = connectors[connectorName];
if (!!connector.prototype) {
ctx.connectors[connectorName] = new connector(ctx);
}
else {
throw new Error("Connector must be a function or an class");
}
});
return root;
};
_1.addSchemaLevelResolveFunction(schema, attachconnectorFn);
});
exports.default = attachConnectorsToContext;
//# sourceMappingURL=attachConnectorsToContext.js.map

1
node_modules/graphql-tools/dist/generate/attachConnectorsToContext.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"attachConnectorsToContext.js","sourceRoot":"","sources":["../../src/generate/attachConnectorsToContext.ts"],"names":[],"mappings":";AAAA,mCAA8D;AAE9D,6DAAkD;AAIlD,sBAAkD;AAElD,uEAAuE;AACvE,2EAA2E;AAC3E,yEAAyE;AACzE,iEAAiE;AACjE,IAAM,yBAAyB,GAAG,iCAAU,CAC1C;IACE,OAAO,EAAE,OAAO;IAChB,GAAG,EAAE,yDAAyD;CAC/D,EACD,UAAS,MAAqB,EAAE,UAAuB;IACrD,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC,MAAM,YAAY,uBAAa,CAAC,EAAE;QACjD,MAAM,IAAI,KAAK,CACb,+CAA+C;YAC7C,8EAA8E,CACjF,CAAC;KACH;IAED,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE;QAClC,IAAM,aAAa,GAAG,OAAO,UAAU,CAAC;QACxC,MAAM,IAAI,KAAK,CACb,mDAAiD,aAAe,CACjE,CAAC;KACH;IACD,IAAI,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE;QACxC,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;KAClE;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;QAC7B,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;KACxE;IACD,IAAI,MAAM,CAAC,2BAA2B,CAAC,EAAE;QACvC,MAAM,IAAI,KAAK,CACb,sEAAsE,CACvE,CAAC;KACH;IACD,MAAM,CAAC,2BAA2B,CAAC,GAAG,IAAI,CAAC;IAC3C,IAAM,iBAAiB,GAAmC,UACxD,IAAS,EACT,IAA4B,EAC5B,GAAQ;QAER,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE;YAC3B,6EAA6E;YAC7E,oDAAoD;YACpD,IAAM,WAAW,GAAG,OAAO,GAAG,CAAC;YAC/B,MAAM,IAAI,KAAK,CACb,+DAA6D,WAAa,CAC3E,CAAC;SACH;QACD,IAAI,OAAO,GAAG,CAAC,UAAU,KAAK,WAAW,EAAE;YACzC,GAAG,CAAC,UAAU,GAAG,EAAE,CAAC;SACrB;QACD,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,UAAA,aAAa;YAC3C,IAAI,SAAS,GAAe,UAAU,CAAC,aAAa,CAAC,CAAC;YACtD,IAAI,CAAC,CAAC,SAAS,CAAC,SAAS,EAAE;gBACzB,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,GAAG,IAAoB,SAAU,CAAC,GAAG,CAAC,CAAC;aACrE;iBAAM;gBACL,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;aAC7D;QACH,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;IACF,gCAA6B,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;AAC3D,CAAC,CACF,CAAC;AAEF,kBAAe,yBAAyB,CAAC"}

4
node_modules/graphql-tools/dist/generate/attachDirectiveResolvers.d.ts generated vendored Normal file
View File

@@ -0,0 +1,4 @@
import { GraphQLSchema } from 'graphql';
import { IDirectiveResolvers } from '../Interfaces';
declare function attachDirectiveResolvers(schema: GraphQLSchema, directiveResolvers: IDirectiveResolvers<any, any>): void;
export default attachDirectiveResolvers;

89
node_modules/graphql-tools/dist/generate/attachDirectiveResolvers.js generated vendored Normal file
View File

@@ -0,0 +1,89 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
var schemaVisitor_1 = require("../schemaVisitor");
function attachDirectiveResolvers(schema, directiveResolvers) {
if (typeof directiveResolvers !== 'object') {
throw new Error("Expected directiveResolvers to be of type object, got " + typeof directiveResolvers);
}
if (Array.isArray(directiveResolvers)) {
throw new Error('Expected directiveResolvers to be of type object, got Array');
}
var schemaDirectives = Object.create(null);
Object.keys(directiveResolvers).forEach(function (directiveName) {
schemaDirectives[directiveName] = /** @class */ (function (_super) {
__extends(class_1, _super);
function class_1() {
return _super !== null && _super.apply(this, arguments) || this;
}
class_1.prototype.visitFieldDefinition = function (field) {
var _this = this;
var resolver = directiveResolvers[directiveName];
var originalResolver = field.resolve || graphql_1.defaultFieldResolver;
var directiveArgs = this.args;
field.resolve = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var source = args[0] /* original args */, context = args[2], info = args[3];
return resolver(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
return [2 /*return*/, originalResolver.apply(field, args)];
}); }); }, source, directiveArgs, context, info);
};
};
return class_1;
}(schemaVisitor_1.SchemaDirectiveVisitor));
});
schemaVisitor_1.SchemaDirectiveVisitor.visitSchemaDirectives(schema, schemaDirectives);
}
exports.default = attachDirectiveResolvers;
//# sourceMappingURL=attachDirectiveResolvers.js.map

1
node_modules/graphql-tools/dist/generate/attachDirectiveResolvers.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"attachDirectiveResolvers.js","sourceRoot":"","sources":["../../src/generate/attachDirectiveResolvers.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,mCAA4E;AAE5E,kDAA0D;AAE1D,SAAS,wBAAwB,CAC/B,MAAqB,EACrB,kBAAiD;IAEjD,IAAI,OAAO,kBAAkB,KAAK,QAAQ,EAAE;QAC1C,MAAM,IAAI,KAAK,CACb,2DAAyD,OAAO,kBAAoB,CACrF,CAAC;KACH;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,kBAAkB,CAAC,EAAE;QACrC,MAAM,IAAI,KAAK,CACb,6DAA6D,CAC9D,CAAC;KACH;IAED,IAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAE7C,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,OAAO,CAAC,UAAA,aAAa;QACnD,gBAAgB,CAAC,aAAa,CAAC;YAAiB,2BAAsB;YAApC;;YAgBlC,CAAC;YAfQ,sCAAoB,GAA3B,UAA4B,KAA6B;gBAAzD,iBAcC;gBAbC,IAAM,QAAQ,GAAG,kBAAkB,CAAC,aAAa,CAAC,CAAC;gBACnD,IAAM,gBAAgB,GAAG,KAAK,CAAC,OAAO,IAAI,8BAAoB,CAAC;gBAC/D,IAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC;gBAChC,KAAK,CAAC,OAAO,GAAG;oBAAC,cAAc;yBAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;wBAAd,yBAAc;;oBACtB,IAAA,gBAAM,CAAC,mBAAmB,EAAI,iBAAO,EAAE,cAAI,CAAS;oBAC3D,OAAO,QAAQ,CACb;wBAAY,sBAAA,gBAAgB,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,EAAA;6BAAA,EAC/C,MAAM,EACN,aAAa,EACb,OAAO,EACP,IAAI,CACL,CAAC;gBACJ,CAAC,CAAC;YACJ,CAAC;YACH,cAAC;QAAD,CAAC,AAhBiC,CAAc,sCAAsB,EAgBrE,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,sCAAsB,CAAC,qBAAqB,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;AACzE,CAAC;AAED,kBAAe,wBAAwB,CAAC"}

4
node_modules/graphql-tools/dist/generate/buildSchemaFromTypeDefinitions.d.ts generated vendored Normal file
View File

@@ -0,0 +1,4 @@
import { GraphQLSchema } from 'graphql';
import { ITypeDefinitions, GraphQLParseOptions } from '../Interfaces';
declare function buildSchemaFromTypeDefinitions(typeDefinitions: ITypeDefinitions, parseOptions?: GraphQLParseOptions): GraphQLSchema;
export default buildSchemaFromTypeDefinitions;

37
node_modules/graphql-tools/dist/generate/buildSchemaFromTypeDefinitions.js generated vendored Normal file
View File

@@ -0,0 +1,37 @@
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
var _1 = require(".");
var filterExtensionDefinitions_1 = require("./filterExtensionDefinitions");
function buildSchemaFromTypeDefinitions(typeDefinitions, parseOptions) {
// TODO: accept only array here, otherwise interfaces get confusing.
var myDefinitions = typeDefinitions;
var astDocument;
if (isDocumentNode(typeDefinitions)) {
astDocument = typeDefinitions;
}
else if (typeof myDefinitions !== 'string') {
if (!Array.isArray(myDefinitions)) {
var type = typeof myDefinitions;
throw new _1.SchemaError("typeDefs must be a string, array or schema AST, got " + type);
}
myDefinitions = _1.concatenateTypeDefs(myDefinitions);
}
if (typeof myDefinitions === 'string') {
astDocument = graphql_1.parse(myDefinitions, parseOptions);
}
var backcompatOptions = { commentDescriptions: true };
var typesAst = filterExtensionDefinitions_1.default(astDocument);
// TODO fix types https://github.com/apollographql/graphql-tools/issues/542
var schema = graphql_1.buildASTSchema(typesAst, backcompatOptions);
var extensionsAst = _1.extractExtensionDefinitions(astDocument);
if (extensionsAst.definitions.length > 0) {
// TODO fix types https://github.com/apollographql/graphql-tools/issues/542
schema = graphql_1.extendSchema(schema, extensionsAst, backcompatOptions);
}
return schema;
}
function isDocumentNode(typeDefinitions) {
return typeDefinitions.kind !== undefined;
}
exports.default = buildSchemaFromTypeDefinitions;
//# sourceMappingURL=buildSchemaFromTypeDefinitions.js.map

1
node_modules/graphql-tools/dist/generate/buildSchemaFromTypeDefinitions.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"buildSchemaFromTypeDefinitions.js","sourceRoot":"","sources":["../../src/generate/buildSchemaFromTypeDefinitions.ts"],"names":[],"mappings":";AAAA,mCAMiB;AAGjB,sBAIW;AACX,2EAAsE;AAEtE,SAAS,8BAA8B,CACrC,eAAiC,EACjC,YAAkC;IAElC,oEAAoE;IACpE,IAAI,aAAa,GAAG,eAAe,CAAC;IACpC,IAAI,WAAyB,CAAC;IAE9B,IAAI,cAAc,CAAC,eAAe,CAAC,EAAE;QACnC,WAAW,GAAG,eAAe,CAAC;KAC/B;SAAM,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE;QAC5C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE;YACjC,IAAM,IAAI,GAAG,OAAO,aAAa,CAAC;YAClC,MAAM,IAAI,cAAW,CACnB,yDAAuD,IAAM,CAC9D,CAAC;SACH;QACD,aAAa,GAAG,sBAAmB,CAAC,aAAa,CAAC,CAAC;KACpD;IAED,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE;QACrC,WAAW,GAAG,eAAK,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;KAClD;IAED,IAAM,iBAAiB,GAAG,EAAE,mBAAmB,EAAE,IAAI,EAAE,CAAC;IACxD,IAAM,QAAQ,GAAG,oCAA0B,CAAC,WAAW,CAAC,CAAC;IAEzD,2EAA2E;IAC3E,IAAI,MAAM,GAAmB,wBAAsB,CACjD,QAAQ,EACR,iBAAiB,CAClB,CAAC;IAEF,IAAM,aAAa,GAAG,8BAA2B,CAAC,WAAW,CAAC,CAAC;IAC/D,IAAI,aAAa,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;QACxC,2EAA2E;QAC3E,MAAM,GAAI,sBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,iBAAiB,CAAC,CAAC;KAC1E;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,cAAc,CACrB,eAAiC;IAEjC,OAAsB,eAAgB,CAAC,IAAI,KAAK,SAAS,CAAC;AAC5D,CAAC;AAED,kBAAe,8BAA8B,CAAC"}

4
node_modules/graphql-tools/dist/generate/chainResolvers.d.ts generated vendored Normal file
View File

@@ -0,0 +1,4 @@
import { GraphQLResolveInfo, GraphQLFieldResolver } from 'graphql';
export declare function chainResolvers(resolvers: GraphQLFieldResolver<any, any>[]): (root: any, args: {
[argName: string]: any;
}, ctx: any, info: GraphQLResolveInfo) => any;

14
node_modules/graphql-tools/dist/generate/chainResolvers.js generated vendored Normal file
View File

@@ -0,0 +1,14 @@
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
function chainResolvers(resolvers) {
return function (root, args, ctx, info) {
return resolvers.reduce(function (prev, curResolver) {
if (curResolver) {
return curResolver(prev, args, ctx, info);
}
return graphql_1.defaultFieldResolver(prev, args, ctx, info);
}, root);
};
}
exports.chainResolvers = chainResolvers;
//# sourceMappingURL=chainResolvers.js.map

1
node_modules/graphql-tools/dist/generate/chainResolvers.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"chainResolvers.js","sourceRoot":"","sources":["../../src/generate/chainResolvers.ts"],"names":[],"mappings":";AAAA,mCAAyF;AAEzF,SAAgB,cAAc,CAAC,SAA2C;IACxE,OAAO,UAAC,IAAS,EAAE,IAAgC,EAAE,GAAQ,EAAE,IAAwB;QACrF,OAAO,SAAS,CAAC,MAAM,CAAC,UAAC,IAAI,EAAE,WAAW;YACxC,IAAI,WAAW,EAAE;gBACf,OAAO,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;aAC3C;YAED,OAAO,8BAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;QACrD,CAAC,EAAE,IAAI,CAAC,CAAC;IACX,CAAC,CAAC;AACJ,CAAC;AAVD,wCAUC"}

3
node_modules/graphql-tools/dist/generate/checkForResolveTypeResolver.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
import { GraphQLSchema } from 'graphql';
declare function checkForResolveTypeResolver(schema: GraphQLSchema, requireResolversForResolveType?: boolean): void;
export default checkForResolveTypeResolver;

27
node_modules/graphql-tools/dist/generate/checkForResolveTypeResolver.js generated vendored Normal file
View File

@@ -0,0 +1,27 @@
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
var _1 = require(".");
// If we have any union or interface types throw if no there is no resolveType or isTypeOf resolvers
function checkForResolveTypeResolver(schema, requireResolversForResolveType) {
Object.keys(schema.getTypeMap())
.map(function (typeName) { return schema.getType(typeName); })
.forEach(function (type) {
if (!(type instanceof graphql_1.GraphQLUnionType ||
type instanceof graphql_1.GraphQLInterfaceType)) {
return;
}
if (!type.resolveType) {
if (requireResolversForResolveType === false) {
return;
}
if (requireResolversForResolveType === true) {
throw new _1.SchemaError("Type \"" + type.name + "\" is missing a \"resolveType\" resolver");
}
// tslint:disable-next-line:max-line-length
console.warn("Type \"" + type.name + "\" is missing a \"__resolveType\" resolver. Pass false into " +
"\"resolverValidationOptions.requireResolversForResolveType\" to disable this warning.");
}
});
}
exports.default = checkForResolveTypeResolver;
//# sourceMappingURL=checkForResolveTypeResolver.js.map

1
node_modules/graphql-tools/dist/generate/checkForResolveTypeResolver.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"checkForResolveTypeResolver.js","sourceRoot":"","sources":["../../src/generate/checkForResolveTypeResolver.ts"],"names":[],"mappings":";AAAA,mCAAgF;AAEhF,sBAAgC;AAEhC,oGAAoG;AACpG,SAAS,2BAA2B,CAClC,MAAqB,EACrB,8BAAwC;IAExC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;SAC7B,GAAG,CAAC,UAAA,QAAQ,IAAI,OAAA,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAxB,CAAwB,CAAC;SACzC,OAAO,CAAC,UAAC,IAA6C;QACrD,IACE,CAAC,CACC,IAAI,YAAY,0BAAgB;YAChC,IAAI,YAAY,8BAAoB,CACrC,EACD;YACA,OAAO;SACR;QACD,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACrB,IAAI,8BAA8B,KAAK,KAAK,EAAE;gBAC5C,OAAO;aACR;YACD,IAAI,8BAA8B,KAAK,IAAI,EAAE;gBAC3C,MAAM,IAAI,cAAW,CACnB,YAAS,IAAI,CAAC,IAAI,6CAAuC,CAC1D,CAAC;aACH;YACD,2CAA2C;YAC3C,OAAO,CAAC,IAAI,CACV,YACE,IAAI,CAAC,IAAI,iEACgD;gBAC3D,uFAAqF,CACtF,CAAC;SACH;IACH,CAAC,CAAC,CAAC;AACP,CAAC;AACD,kBAAe,2BAA2B,CAAC"}

3
node_modules/graphql-tools/dist/generate/concatenateTypeDefs.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
import { ITypedef } from '../Interfaces';
declare function concatenateTypeDefs(typeDefinitionsAry: ITypedef[], calledFunctionRefs?: any): string;
export default concatenateTypeDefs;

41
node_modules/graphql-tools/dist/generate/concatenateTypeDefs.js generated vendored Normal file
View File

@@ -0,0 +1,41 @@
var __spreadArrays = (this && this.__spreadArrays) || function () {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
var _1 = require(".");
function concatenateTypeDefs(typeDefinitionsAry, calledFunctionRefs) {
if (calledFunctionRefs === void 0) { calledFunctionRefs = []; }
var resolvedTypeDefinitions = [];
typeDefinitionsAry.forEach(function (typeDef) {
if (typeDef.kind !== undefined) {
typeDef = graphql_1.print(typeDef);
}
if (typeof typeDef === 'function') {
if (calledFunctionRefs.indexOf(typeDef) === -1) {
calledFunctionRefs.push(typeDef);
resolvedTypeDefinitions = resolvedTypeDefinitions.concat(concatenateTypeDefs(typeDef(), calledFunctionRefs));
}
}
else if (typeof typeDef === 'string') {
resolvedTypeDefinitions.push(typeDef.trim());
}
else {
var type = typeof typeDef;
throw new _1.SchemaError("typeDef array must contain only strings and functions, got " + type);
}
});
return uniq(resolvedTypeDefinitions.map(function (x) { return x.trim(); })).join('\n');
}
function uniq(array) {
return array.reduce(function (accumulator, currentValue) {
return accumulator.indexOf(currentValue) === -1
? __spreadArrays(accumulator, [currentValue]) : accumulator;
}, []);
}
exports.default = concatenateTypeDefs;
//# sourceMappingURL=concatenateTypeDefs.js.map

1
node_modules/graphql-tools/dist/generate/concatenateTypeDefs.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"concatenateTypeDefs.js","sourceRoot":"","sources":["../../src/generate/concatenateTypeDefs.ts"],"names":[],"mappings":";;;;;;;;AAAA,mCAAuD;AAGvD,sBAAgC;AAEhC,SAAS,mBAAmB,CAC1B,kBAA8B,EAC9B,kBAA8B;IAA9B,mCAAA,EAAA,qBAAqB,EAAS;IAE9B,IAAI,uBAAuB,GAAa,EAAE,CAAC;IAC3C,kBAAkB,CAAC,OAAO,CAAC,UAAC,OAAiB;QAC3C,IAAmB,OAAQ,CAAC,IAAI,KAAK,SAAS,EAAE;YAC9C,OAAO,GAAG,eAAK,CAAC,OAAkB,CAAC,CAAC;SACrC;QAED,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE;YACjC,IAAI,kBAAkB,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE;gBAC9C,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACjC,uBAAuB,GAAG,uBAAuB,CAAC,MAAM,CACtD,mBAAmB,CAAC,OAAO,EAAE,EAAE,kBAAkB,CAAC,CACnD,CAAC;aACH;SACF;aAAM,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;YACtC,uBAAuB,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;SAC9C;aAAM;YACL,IAAM,IAAI,GAAG,OAAO,OAAO,CAAC;YAC5B,MAAM,IAAI,cAAW,CACnB,gEAA8D,IAAM,CACrE,CAAC;SACH;IACH,CAAC,CAAC,CAAC;IACH,OAAO,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,IAAI,EAAE,EAAR,CAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACrE,CAAC;AAED,SAAS,IAAI,CAAC,KAAiB;IAC7B,OAAO,KAAK,CAAC,MAAM,CAAC,UAAC,WAAW,EAAE,YAAY;QAC5C,OAAO,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;YAC7C,CAAC,gBAAK,WAAW,GAAE,YAAY,GAC/B,CAAC,CAAC,WAAW,CAAC;IAClB,CAAC,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED,kBAAe,mBAAmB,CAAC"}

4
node_modules/graphql-tools/dist/generate/decorateWithLogger.d.ts generated vendored Normal file
View File

@@ -0,0 +1,4 @@
import { GraphQLFieldResolver } from 'graphql';
import { ILogger } from '../Interfaces';
declare function decorateWithLogger(fn: GraphQLFieldResolver<any, any> | undefined, logger: ILogger, hint: string): GraphQLFieldResolver<any, any>;
export default decorateWithLogger;

48
node_modules/graphql-tools/dist/generate/decorateWithLogger.js generated vendored Normal file
View File

@@ -0,0 +1,48 @@
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
/*
* fn: The function to decorate with the logger
* logger: an object instance of type Logger
* hint: an optional hint to add to the error's message
*/
function decorateWithLogger(fn, logger, hint) {
if (typeof fn === 'undefined') {
fn = graphql_1.defaultFieldResolver;
}
var logError = function (e) {
// TODO: clone the error properly
var newE = new Error();
newE.stack = e.stack;
/* istanbul ignore else: always get the hint from addErrorLoggingToSchema */
if (hint) {
newE['originalMessage'] = e.message;
newE['message'] = "Error in resolver " + hint + "\n" + e.message;
}
logger.log(newE);
};
return function (root, args, ctx, info) {
try {
var result = fn(root, args, ctx, info);
// If the resolve function returns a Promise log any Promise rejects.
if (result &&
typeof result.then === 'function' &&
typeof result.catch === 'function') {
result.catch(function (reason) {
// make sure that it's an error we're logging.
var error = reason instanceof Error ? reason : new Error(reason);
logError(error);
// We don't want to leave an unhandled exception so pass on error.
return reason;
});
}
return result;
}
catch (e) {
logError(e);
// we want to pass on the error, just in case.
throw e;
}
};
}
exports.default = decorateWithLogger;
//# sourceMappingURL=decorateWithLogger.js.map

1
node_modules/graphql-tools/dist/generate/decorateWithLogger.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"decorateWithLogger.js","sourceRoot":"","sources":["../../src/generate/decorateWithLogger.ts"],"names":[],"mappings":";AAAA,mCAAqE;AAGrE;;;;GAIG;AACH,SAAS,kBAAkB,CACzB,EAA8C,EAC9C,MAAe,EACf,IAAY;IAEZ,IAAI,OAAO,EAAE,KAAK,WAAW,EAAE;QAC7B,EAAE,GAAG,8BAAoB,CAAC;KAC3B;IAED,IAAM,QAAQ,GAAG,UAAC,CAAQ;QACxB,iCAAiC;QACjC,IAAM,IAAI,GAAG,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC;QACrB,4EAA4E;QAC5E,IAAI,IAAI,EAAE;YACR,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC;YACpC,IAAI,CAAC,SAAS,CAAC,GAAG,uBAAqB,IAAI,UAAK,CAAC,CAAC,OAAS,CAAC;SAC7D;QACD,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACnB,CAAC,CAAC;IAEF,OAAO,UAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI;QAC3B,IAAI;YACF,IAAM,MAAM,GAAG,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;YACzC,qEAAqE;YACrE,IACE,MAAM;gBACN,OAAO,MAAM,CAAC,IAAI,KAAK,UAAU;gBACjC,OAAO,MAAM,CAAC,KAAK,KAAK,UAAU,EAClC;gBACA,MAAM,CAAC,KAAK,CAAC,UAAC,MAAsB;oBAClC,8CAA8C;oBAC9C,IAAM,KAAK,GAAG,MAAM,YAAY,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC;oBACnE,QAAQ,CAAC,KAAK,CAAC,CAAC;oBAEhB,kEAAkE;oBAClE,OAAO,MAAM,CAAC;gBAChB,CAAC,CAAC,CAAC;aACJ;YACD,OAAO,MAAM,CAAC;SACf;QAAC,OAAO,CAAC,EAAE;YACV,QAAQ,CAAC,CAAC,CAAC,CAAC;YACZ,8CAA8C;YAC9C,MAAM,CAAC,CAAC;SACT;IACH,CAAC,CAAC;AACJ,CAAC;AAED,kBAAe,kBAAkB,CAAC"}

4
node_modules/graphql-tools/dist/generate/extendResolversFromInterfaces.d.ts generated vendored Normal file
View File

@@ -0,0 +1,4 @@
import { GraphQLSchema } from 'graphql';
import { IResolvers } from '../Interfaces';
declare function extendResolversFromInterfaces(schema: GraphQLSchema, resolvers: IResolvers): IResolvers<any, any>;
export default extendResolversFromInterfaces;

42
node_modules/graphql-tools/dist/generate/extendResolversFromInterfaces.js generated vendored Normal file
View File

@@ -0,0 +1,42 @@
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __spreadArrays = (this && this.__spreadArrays) || function () {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
function extendResolversFromInterfaces(schema, resolvers) {
var typeNames = Object.keys(__assign(__assign({}, schema.getTypeMap()), resolvers));
var extendedResolvers = {};
typeNames.forEach(function (typeName) {
var typeResolvers = resolvers[typeName];
var type = schema.getType(typeName);
if (type instanceof graphql_1.GraphQLObjectType) {
var interfaceResolvers = type
.getInterfaces()
.map(function (iFace) { return resolvers[iFace.name]; });
extendedResolvers[typeName] = Object.assign.apply(Object, __spreadArrays([{}], interfaceResolvers, [typeResolvers]));
}
else {
if (typeResolvers) {
extendedResolvers[typeName] = typeResolvers;
}
}
});
return extendedResolvers;
}
exports.default = extendResolversFromInterfaces;
//# sourceMappingURL=extendResolversFromInterfaces.js.map

1
node_modules/graphql-tools/dist/generate/extendResolversFromInterfaces.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"extendResolversFromInterfaces.js","sourceRoot":"","sources":["../../src/generate/extendResolversFromInterfaces.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAAA,mCAA2D;AAI3D,SAAS,6BAA6B,CACpC,MAAqB,EACrB,SAAqB;IAErB,IAAM,SAAS,GAAG,MAAM,CAAC,IAAI,uBACxB,MAAM,CAAC,UAAU,EAAE,GACnB,SAAS,EACZ,CAAC;IAEH,IAAM,iBAAiB,GAAe,EAAE,CAAC;IACzC,SAAS,CAAC,OAAO,CAAC,UAAA,QAAQ;QACxB,IAAM,aAAa,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;QAC1C,IAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACtC,IAAI,IAAI,YAAY,2BAAiB,EAAE;YACrC,IAAM,kBAAkB,GAAG,IAAI;iBAC5B,aAAa,EAAE;iBACf,GAAG,CAAC,UAAA,KAAK,IAAI,OAAA,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,EAArB,CAAqB,CAAC,CAAC;YACvC,iBAAiB,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,MAAM,OAAb,MAAM,kBAClC,EAAE,GACC,kBAAkB,GACrB,aAAa,GACd,CAAC;SACH;aAAM;YACL,IAAI,aAAa,EAAE;gBACjB,iBAAiB,CAAC,QAAQ,CAAC,GAAG,aAAa,CAAC;aAC7C;SACF;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,iBAAiB,CAAC;AAC3B,CAAC;AAED,kBAAe,6BAA6B,CAAC"}

4
node_modules/graphql-tools/dist/generate/extractExtensionDefinitions.d.ts generated vendored Normal file
View File

@@ -0,0 +1,4 @@
import { DocumentNode, DefinitionNode } from 'graphql';
export default function extractExtensionDefinitions(ast: DocumentNode): DocumentNode & {
definitions: DefinitionNode[];
};

20
node_modules/graphql-tools/dist/generate/extractExtensionDefinitions.js generated vendored Normal file
View File

@@ -0,0 +1,20 @@
Object.defineProperty(exports, "__esModule", { value: true });
var newExtensionDefinitionKind = 'ObjectTypeExtension';
var interfaceExtensionDefinitionKind = 'InterfaceTypeExtension';
var inputObjectExtensionDefinitionKind = 'InputObjectTypeExtension';
var unionExtensionDefinitionKind = 'UnionTypeExtension';
var enumExtensionDefinitionKind = 'EnumTypeExtension';
function extractExtensionDefinitions(ast) {
var extensionDefs = ast.definitions.filter(function (def) {
return def.kind === newExtensionDefinitionKind ||
def.kind === interfaceExtensionDefinitionKind ||
def.kind === inputObjectExtensionDefinitionKind ||
def.kind === unionExtensionDefinitionKind ||
def.kind === enumExtensionDefinitionKind;
});
return Object.assign({}, ast, {
definitions: extensionDefs,
});
}
exports.default = extractExtensionDefinitions;
//# sourceMappingURL=extractExtensionDefinitions.js.map

1
node_modules/graphql-tools/dist/generate/extractExtensionDefinitions.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"extractExtensionDefinitions.js","sourceRoot":"","sources":["../../src/generate/extractExtensionDefinitions.ts"],"names":[],"mappings":";AAEA,IAAM,0BAA0B,GAAG,qBAAqB,CAAC;AACzD,IAAM,gCAAgC,GAAG,wBAAwB,CAAC;AAClE,IAAM,kCAAkC,GAAG,0BAA0B,CAAC;AACtE,IAAM,4BAA4B,GAAG,oBAAoB,CAAC;AAC1D,IAAM,2BAA2B,GAAG,mBAAmB,CAAC;AAExD,SAAwB,2BAA2B,CAAC,GAAiB;IACnE,IAAM,aAAa,GAAG,GAAG,CAAC,WAAW,CAAC,MAAM,CAC1C,UAAC,GAAmB;QAClB,OAAC,GAAG,CAAC,IAAY,KAAK,0BAA0B;YAC/C,GAAG,CAAC,IAAY,KAAK,gCAAgC;YACrD,GAAG,CAAC,IAAY,KAAK,kCAAkC;YACvD,GAAG,CAAC,IAAY,KAAK,4BAA4B;YACjD,GAAG,CAAC,IAAY,KAAK,2BAA2B;IAJjD,CAIiD,CACpD,CAAC;IAEF,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,GAAG,EAAE;QAC5B,WAAW,EAAE,aAAa;KAC3B,CAAC,CAAC;AACL,CAAC;AAbD,8CAaC"}

6
node_modules/graphql-tools/dist/generate/filterExtensionDefinitions.d.ts generated vendored Normal file
View File

@@ -0,0 +1,6 @@
import { DocumentNode, DefinitionNode } from 'graphql';
export default function filterExtensionDefinitions(ast: DocumentNode): {
definitions: DefinitionNode[];
kind: "Document";
loc?: import("graphql").Location;
};

27
node_modules/graphql-tools/dist/generate/filterExtensionDefinitions.js generated vendored Normal file
View File

@@ -0,0 +1,27 @@
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
function filterExtensionDefinitions(ast) {
var extensionDefs = ast.definitions.filter(function (def) {
return def.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION &&
def.kind !== graphql_1.Kind.INTERFACE_TYPE_EXTENSION &&
def.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION &&
def.kind !== graphql_1.Kind.UNION_TYPE_EXTENSION &&
def.kind !== graphql_1.Kind.ENUM_TYPE_EXTENSION &&
def.kind !== graphql_1.Kind.SCALAR_TYPE_EXTENSION &&
def.kind !== graphql_1.Kind.SCHEMA_EXTENSION;
});
return __assign(__assign({}, ast), { definitions: extensionDefs });
}
exports.default = filterExtensionDefinitions;
//# sourceMappingURL=filterExtensionDefinitions.js.map

1
node_modules/graphql-tools/dist/generate/filterExtensionDefinitions.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"filterExtensionDefinitions.js","sourceRoot":"","sources":["../../src/generate/filterExtensionDefinitions.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,mCAA6D;AAE7D,SAAwB,0BAA0B,CAAC,GAAiB;IAClE,IAAM,aAAa,GAAG,GAAG,CAAC,WAAW,CAAC,MAAM,CAC1C,UAAC,GAAmB;QAClB,OAAA,GAAG,CAAC,IAAI,KAAK,cAAI,CAAC,qBAAqB;YACvC,GAAG,CAAC,IAAI,KAAK,cAAI,CAAC,wBAAwB;YAC1C,GAAG,CAAC,IAAI,KAAK,cAAI,CAAC,2BAA2B;YAC7C,GAAG,CAAC,IAAI,KAAK,cAAI,CAAC,oBAAoB;YACtC,GAAG,CAAC,IAAI,KAAK,cAAI,CAAC,mBAAmB;YACrC,GAAG,CAAC,IAAI,KAAK,cAAI,CAAC,qBAAqB;YACvC,GAAG,CAAC,IAAI,KAAK,cAAI,CAAC,gBAAgB;IANlC,CAMkC,CACrC,CAAC;IAEF,6BACK,GAAG,KACN,WAAW,EAAE,aAAa,IAC1B;AACJ,CAAC;AAhBD,6CAgBC"}

4
node_modules/graphql-tools/dist/generate/forEachField.d.ts generated vendored Normal file
View File

@@ -0,0 +1,4 @@
import { GraphQLSchema } from 'graphql';
import { IFieldIteratorFn } from '../Interfaces';
declare function forEachField(schema: GraphQLSchema, fn: IFieldIteratorFn): void;
export default forEachField;

19
node_modules/graphql-tools/dist/generate/forEachField.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
function forEachField(schema, fn) {
var typeMap = schema.getTypeMap();
Object.keys(typeMap).forEach(function (typeName) {
var type = typeMap[typeName];
// TODO: maybe have an option to include these?
if (!graphql_1.getNamedType(type).name.startsWith('__') &&
type instanceof graphql_1.GraphQLObjectType) {
var fields_1 = type.getFields();
Object.keys(fields_1).forEach(function (fieldName) {
var field = fields_1[fieldName];
fn(field, typeName, fieldName);
});
}
});
}
exports.default = forEachField;
//# sourceMappingURL=forEachField.js.map

1
node_modules/graphql-tools/dist/generate/forEachField.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"forEachField.js","sourceRoot":"","sources":["../../src/generate/forEachField.ts"],"names":[],"mappings":";AAAA,mCAAyE;AAGzE,SAAS,YAAY,CAAC,MAAqB,EAAE,EAAoB;IAC/D,IAAM,OAAO,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC;IACpC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,UAAA,QAAQ;QACnC,IAAM,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;QAE/B,+CAA+C;QAC/C,IACE,CAAC,sBAAY,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;YACzC,IAAI,YAAY,2BAAiB,EACjC;YACA,IAAM,QAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YAChC,MAAM,CAAC,IAAI,CAAC,QAAM,CAAC,CAAC,OAAO,CAAC,UAAA,SAAS;gBACnC,IAAM,KAAK,GAAG,QAAM,CAAC,SAAS,CAAC,CAAC;gBAChC,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;YACjC,CAAC,CAAC,CAAC;SACJ;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAED,kBAAe,YAAY,CAAC"}

14
node_modules/graphql-tools/dist/generate/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,14 @@
export { default as addResolveFunctionsToSchema } from './addResolveFunctionsToSchema';
export { default as addSchemaLevelResolveFunction } from './addSchemaLevelResolveFunction';
export { default as assertResolveFunctionsPresent } from './assertResolveFunctionsPresent';
export { default as attachDirectiveResolvers } from './attachDirectiveResolvers';
export { default as attachConnectorsToContext } from './attachConnectorsToContext';
export { default as buildSchemaFromTypeDefinitions } from './buildSchemaFromTypeDefinitions';
export { chainResolvers } from './chainResolvers';
export { default as checkForResolveTypeResolver } from './checkForResolveTypeResolver';
export { default as concatenateTypeDefs } from './concatenateTypeDefs';
export { default as decorateWithLogger } from './decorateWithLogger';
export { default as extendResolversFromInterfaces } from './extendResolversFromInterfaces';
export { default as extractExtensionDefinitions } from './extractExtensionDefinitions';
export { default as forEachField } from './forEachField';
export { default as SchemaError } from './SchemaError';

30
node_modules/graphql-tools/dist/generate/index.js generated vendored Normal file
View File

@@ -0,0 +1,30 @@
Object.defineProperty(exports, "__esModule", { value: true });
var addResolveFunctionsToSchema_1 = require("./addResolveFunctionsToSchema");
exports.addResolveFunctionsToSchema = addResolveFunctionsToSchema_1.default;
var addSchemaLevelResolveFunction_1 = require("./addSchemaLevelResolveFunction");
exports.addSchemaLevelResolveFunction = addSchemaLevelResolveFunction_1.default;
var assertResolveFunctionsPresent_1 = require("./assertResolveFunctionsPresent");
exports.assertResolveFunctionsPresent = assertResolveFunctionsPresent_1.default;
var attachDirectiveResolvers_1 = require("./attachDirectiveResolvers");
exports.attachDirectiveResolvers = attachDirectiveResolvers_1.default;
var attachConnectorsToContext_1 = require("./attachConnectorsToContext");
exports.attachConnectorsToContext = attachConnectorsToContext_1.default;
var buildSchemaFromTypeDefinitions_1 = require("./buildSchemaFromTypeDefinitions");
exports.buildSchemaFromTypeDefinitions = buildSchemaFromTypeDefinitions_1.default;
var chainResolvers_1 = require("./chainResolvers");
exports.chainResolvers = chainResolvers_1.chainResolvers;
var checkForResolveTypeResolver_1 = require("./checkForResolveTypeResolver");
exports.checkForResolveTypeResolver = checkForResolveTypeResolver_1.default;
var concatenateTypeDefs_1 = require("./concatenateTypeDefs");
exports.concatenateTypeDefs = concatenateTypeDefs_1.default;
var decorateWithLogger_1 = require("./decorateWithLogger");
exports.decorateWithLogger = decorateWithLogger_1.default;
var extendResolversFromInterfaces_1 = require("./extendResolversFromInterfaces");
exports.extendResolversFromInterfaces = extendResolversFromInterfaces_1.default;
var extractExtensionDefinitions_1 = require("./extractExtensionDefinitions");
exports.extractExtensionDefinitions = extractExtensionDefinitions_1.default;
var forEachField_1 = require("./forEachField");
exports.forEachField = forEachField_1.default;
var SchemaError_1 = require("./SchemaError");
exports.SchemaError = SchemaError_1.default;
//# sourceMappingURL=index.js.map

1
node_modules/graphql-tools/dist/generate/index.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/generate/index.ts"],"names":[],"mappings":";AAAA,6EAAuF;AAA9E,oEAAA,OAAO,CAA+B;AAC/C,iFAA2F;AAAlF,wEAAA,OAAO,CAAiC;AACjD,iFAA2F;AAAlF,wEAAA,OAAO,CAAiC;AACjD,uEAAiF;AAAxE,8DAAA,OAAO,CAA4B;AAC5C,yEAAmF;AAA1E,gEAAA,OAAO,CAA6B;AAC7C,mFAA6F;AAApF,0EAAA,OAAO,CAAkC;AAClD,mDAAkD;AAAzC,0CAAA,cAAc,CAAA;AACvB,6EAAuF;AAA9E,oEAAA,OAAO,CAA+B;AAC/C,6DAAuE;AAA9D,oDAAA,OAAO,CAAuB;AACvC,2DAAqE;AAA5D,kDAAA,OAAO,CAAsB;AACtC,iFAA2F;AAAlF,wEAAA,OAAO,CAAiC;AACjD,6EAAuF;AAA9E,oEAAA,OAAO,CAA+B;AAC/C,+CAAyD;AAAhD,sCAAA,OAAO,CAAgB;AAChC,6CAAuD;AAA9C,oCAAA,OAAO,CAAe"}

2
node_modules/graphql-tools/dist/implementsAbstractType.d.ts generated vendored Normal file
View File

@@ -0,0 +1,2 @@
import { GraphQLType, GraphQLSchema } from 'graphql';
export default function implementsAbstractType(schema: GraphQLSchema, typeA: GraphQLType, typeB: GraphQLType): boolean;

15
node_modules/graphql-tools/dist/implementsAbstractType.js generated vendored Normal file
View File

@@ -0,0 +1,15 @@
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
function implementsAbstractType(schema, typeA, typeB) {
if (typeA === typeB) {
return true;
}
else if (graphql_1.isCompositeType(typeA) && graphql_1.isCompositeType(typeB)) {
return graphql_1.doTypesOverlap(schema, typeA, typeB);
}
else {
return false;
}
}
exports.default = implementsAbstractType;
//# sourceMappingURL=implementsAbstractType.js.map

1
node_modules/graphql-tools/dist/implementsAbstractType.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"implementsAbstractType.js","sourceRoot":"","sources":["../src/implementsAbstractType.ts"],"names":[],"mappings":";AAAA,mCAKiB;AAEjB,SAAwB,sBAAsB,CAC5C,MAAqB,EACrB,KAAkB,EAClB,KAAkB;IAElB,IAAI,KAAK,KAAK,KAAK,EAAE;QACnB,OAAO,IAAI,CAAC;KACb;SAAM,IAAI,yBAAe,CAAC,KAAK,CAAC,IAAI,yBAAe,CAAC,KAAK,CAAC,EAAE;QAC3D,OAAO,wBAAc,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;KAC7C;SAAM;QACL,OAAO,KAAK,CAAC;KACd;AACH,CAAC;AAZD,yCAYC"}

6
node_modules/graphql-tools/dist/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,6 @@
export * from './Interfaces';
export * from './makeExecutableSchema';
export * from './mock';
export * from './stitching';
export * from './transforms';
export { SchemaDirectiveVisitor } from './schemaVisitor';

11
node_modules/graphql-tools/dist/index.js generated vendored Normal file
View File

@@ -0,0 +1,11 @@
function __export(m) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
Object.defineProperty(exports, "__esModule", { value: true });
__export(require("./makeExecutableSchema"));
__export(require("./mock"));
__export(require("./stitching"));
__export(require("./transforms"));
var schemaVisitor_1 = require("./schemaVisitor");
exports.SchemaDirectiveVisitor = schemaVisitor_1.SchemaDirectiveVisitor;
//# sourceMappingURL=index.js.map

1
node_modules/graphql-tools/dist/index.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;AACA,4CAAuC;AACvC,4BAAuB;AACvB,iCAA4B;AAC5B,kCAA6B;AAC7B,iDAAyD;AAAhD,iDAAA,sBAAsB,CAAA"}

1
node_modules/graphql-tools/dist/isEmptyObject.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export default function isEmptyObject(obj: Object): boolean;

14
node_modules/graphql-tools/dist/isEmptyObject.js generated vendored Normal file
View File

@@ -0,0 +1,14 @@
Object.defineProperty(exports, "__esModule", { value: true });
function isEmptyObject(obj) {
if (!obj) {
return true;
}
for (var key in obj) {
if (Object.hasOwnProperty.call(obj, key)) {
return false;
}
}
return true;
}
exports.default = isEmptyObject;
//# sourceMappingURL=isEmptyObject.js.map

1
node_modules/graphql-tools/dist/isEmptyObject.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"isEmptyObject.js","sourceRoot":"","sources":["../src/isEmptyObject.ts"],"names":[],"mappings":";AAAA,SAAwB,aAAa,CAAC,GAAW;IAC/C,IAAI,CAAC,GAAG,EAAE;QACR,OAAO,IAAI,CAAC;KACb;IAED,KAAK,IAAM,GAAG,IAAI,GAAG,EAAE;QACrB,IAAI,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE;YACxC,OAAO,KAAK,CAAC;SACd;KACF;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAXD,gCAWC"}

3
node_modules/graphql-tools/dist/isSpecifiedScalarType.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
import { GraphQLScalarType } from 'graphql';
export declare const specifiedScalarTypes: Array<GraphQLScalarType>;
export default function isSpecifiedScalarType(type: any): boolean;

22
node_modules/graphql-tools/dist/isSpecifiedScalarType.js generated vendored Normal file
View File

@@ -0,0 +1,22 @@
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
// FIXME: Replace with https://github.com/graphql/graphql-js/blob/master/src/type/scalars.js#L139
exports.specifiedScalarTypes = [
graphql_1.GraphQLString,
graphql_1.GraphQLInt,
graphql_1.GraphQLFloat,
graphql_1.GraphQLBoolean,
graphql_1.GraphQLID,
];
function isSpecifiedScalarType(type) {
return (graphql_1.isNamedType(type) &&
// Would prefer to use specifiedScalarTypes.some(), however %checks needs
// a simple expression.
(type.name === graphql_1.GraphQLString.name ||
type.name === graphql_1.GraphQLInt.name ||
type.name === graphql_1.GraphQLFloat.name ||
type.name === graphql_1.GraphQLBoolean.name ||
type.name === graphql_1.GraphQLID.name));
}
exports.default = isSpecifiedScalarType;
//# sourceMappingURL=isSpecifiedScalarType.js.map

1
node_modules/graphql-tools/dist/isSpecifiedScalarType.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"isSpecifiedScalarType.js","sourceRoot":"","sources":["../src/isSpecifiedScalarType.ts"],"names":[],"mappings":";AAAA,mCAQiB;AAEjB,iGAAiG;AAEpF,QAAA,oBAAoB,GAA6B;IAC5D,uBAAa;IACb,oBAAU;IACV,sBAAY;IACZ,wBAAc;IACd,mBAAS;CACV,CAAC;AAEF,SAAwB,qBAAqB,CAAC,IAAS;IACrD,OAAO,CACL,qBAAW,CAAC,IAAI,CAAC;QACjB,yEAAyE;QACzE,uBAAuB;QACvB,CAAC,IAAI,CAAC,IAAI,KAAK,uBAAa,CAAC,IAAI;YAC/B,IAAI,CAAC,IAAI,KAAK,oBAAU,CAAC,IAAI;YAC7B,IAAI,CAAC,IAAI,KAAK,sBAAY,CAAC,IAAI;YAC/B,IAAI,CAAC,IAAI,KAAK,wBAAc,CAAC,IAAI;YACjC,IAAI,CAAC,IAAI,KAAK,mBAAS,CAAC,IAAI,CAAC,CAChC,CAAC;AACJ,CAAC;AAXD,wCAWC"}

6
node_modules/graphql-tools/dist/makeExecutableSchema.d.ts generated vendored Normal file
View File

@@ -0,0 +1,6 @@
import { GraphQLSchema } from 'graphql';
import { IExecutableSchemaDefinition, ILogger } from './Interfaces';
export declare function makeExecutableSchema<TContext = any>({ typeDefs, resolvers, connectors, logger, allowUndefinedInResolve, resolverValidationOptions, directiveResolvers, schemaDirectives, parseOptions, inheritResolversFromInterfaces }: IExecutableSchemaDefinition<TContext>): GraphQLSchema;
export declare function addCatchUndefinedToSchema(schema: GraphQLSchema): void;
export declare function addErrorLoggingToSchema(schema: GraphQLSchema, logger: ILogger): void;
export * from './generate';

92
node_modules/graphql-tools/dist/makeExecutableSchema.js generated vendored Normal file
View File

@@ -0,0 +1,92 @@
function __export(m) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
var schemaVisitor_1 = require("./schemaVisitor");
var mergeDeep_1 = require("./mergeDeep");
var generate_1 = require("./generate");
function makeExecutableSchema(_a) {
var typeDefs = _a.typeDefs, _b = _a.resolvers, resolvers = _b === void 0 ? {} : _b, connectors = _a.connectors, logger = _a.logger, _c = _a.allowUndefinedInResolve, allowUndefinedInResolve = _c === void 0 ? true : _c, _d = _a.resolverValidationOptions, resolverValidationOptions = _d === void 0 ? {} : _d, _e = _a.directiveResolvers, directiveResolvers = _e === void 0 ? null : _e, _f = _a.schemaDirectives, schemaDirectives = _f === void 0 ? null : _f, _g = _a.parseOptions, parseOptions = _g === void 0 ? {} : _g, _h = _a.inheritResolversFromInterfaces, inheritResolversFromInterfaces = _h === void 0 ? false : _h;
// Validate and clean up arguments
if (typeof resolverValidationOptions !== 'object') {
throw new generate_1.SchemaError('Expected `resolverValidationOptions` to be an object');
}
if (!typeDefs) {
throw new generate_1.SchemaError('Must provide typeDefs');
}
if (!resolvers) {
throw new generate_1.SchemaError('Must provide resolvers');
}
// We allow passing in an array of resolver maps, in which case we merge them
var resolverMap = Array.isArray(resolvers)
? resolvers.filter(function (resolverObj) { return typeof resolverObj === 'object'; }).reduce(mergeDeep_1.default, {})
: resolvers;
// Arguments are now validated and cleaned up
var schema = generate_1.buildSchemaFromTypeDefinitions(typeDefs, parseOptions);
schema = generate_1.addResolveFunctionsToSchema({
schema: schema,
resolvers: resolverMap,
resolverValidationOptions: resolverValidationOptions,
inheritResolversFromInterfaces: inheritResolversFromInterfaces
});
generate_1.assertResolveFunctionsPresent(schema, resolverValidationOptions);
if (!allowUndefinedInResolve) {
addCatchUndefinedToSchema(schema);
}
if (logger) {
addErrorLoggingToSchema(schema, logger);
}
if (typeof resolvers['__schema'] === 'function') {
// TODO a bit of a hack now, better rewrite generateSchema to attach it there.
// not doing that now, because I'd have to rewrite a lot of tests.
generate_1.addSchemaLevelResolveFunction(schema, resolvers['__schema']);
}
if (connectors) {
// connectors are optional, at least for now. That means you can just import them in the resolve
// function if you want.
generate_1.attachConnectorsToContext(schema, connectors);
}
if (directiveResolvers) {
generate_1.attachDirectiveResolvers(schema, directiveResolvers);
}
if (schemaDirectives) {
schemaVisitor_1.SchemaDirectiveVisitor.visitSchemaDirectives(schema, schemaDirectives);
}
return schema;
}
exports.makeExecutableSchema = makeExecutableSchema;
function decorateToCatchUndefined(fn, hint) {
if (typeof fn === 'undefined') {
fn = graphql_1.defaultFieldResolver;
}
return function (root, args, ctx, info) {
var result = fn(root, args, ctx, info);
if (typeof result === 'undefined') {
throw new Error("Resolve function for \"" + hint + "\" returned undefined");
}
return result;
};
}
function addCatchUndefinedToSchema(schema) {
generate_1.forEachField(schema, function (field, typeName, fieldName) {
var errorHint = typeName + "." + fieldName;
field.resolve = decorateToCatchUndefined(field.resolve, errorHint);
});
}
exports.addCatchUndefinedToSchema = addCatchUndefinedToSchema;
function addErrorLoggingToSchema(schema, logger) {
if (!logger) {
throw new Error('Must provide a logger');
}
if (typeof logger.log !== 'function') {
throw new Error('Logger.log must be a function');
}
generate_1.forEachField(schema, function (field, typeName, fieldName) {
var errorHint = typeName + "." + fieldName;
field.resolve = generate_1.decorateWithLogger(field.resolve, logger, errorHint);
});
}
exports.addErrorLoggingToSchema = addErrorLoggingToSchema;
__export(require("./generate"));
//# sourceMappingURL=makeExecutableSchema.js.map

1
node_modules/graphql-tools/dist/makeExecutableSchema.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"makeExecutableSchema.js","sourceRoot":"","sources":["../src/makeExecutableSchema.ts"],"names":[],"mappings":"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"}

1
node_modules/graphql-tools/dist/mergeDeep.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export default function mergeDeep(target: any, source: any): any;

26
node_modules/graphql-tools/dist/mergeDeep.js generated vendored Normal file
View File

@@ -0,0 +1,26 @@
Object.defineProperty(exports, "__esModule", { value: true });
function mergeDeep(target, source) {
var output = Object.assign({}, target);
if (isObject(target) && isObject(source)) {
Object.keys(source).forEach(function (key) {
var _a, _b;
if (isObject(source[key])) {
if (!(key in target)) {
Object.assign(output, (_a = {}, _a[key] = source[key], _a));
}
else {
output[key] = mergeDeep(target[key], source[key]);
}
}
else {
Object.assign(output, (_b = {}, _b[key] = source[key], _b));
}
});
}
return output;
}
exports.default = mergeDeep;
function isObject(item) {
return item && typeof item === 'object' && !Array.isArray(item);
}
//# sourceMappingURL=mergeDeep.js.map

1
node_modules/graphql-tools/dist/mergeDeep.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"mergeDeep.js","sourceRoot":"","sources":["../src/mergeDeep.ts"],"names":[],"mappings":";AAAA,SAAwB,SAAS,CAAC,MAAW,EAAE,MAAW;IACxD,IAAI,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IACvC,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE;QACxC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,UAAA,GAAG;;YAC7B,IAAI,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE;gBACzB,IAAI,CAAC,CAAC,GAAG,IAAI,MAAM,CAAC,EAAE;oBACpB,MAAM,CAAC,MAAM,CAAC,MAAM,YAAI,GAAC,GAAG,IAAG,MAAM,CAAC,GAAG,CAAC,MAAG,CAAC;iBAC/C;qBAAM;oBACL,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;iBACnD;aACF;iBAAM;gBACL,MAAM,CAAC,MAAM,CAAC,MAAM,YAAI,GAAC,GAAG,IAAG,MAAM,CAAC,GAAG,CAAC,MAAG,CAAC;aAC/C;QACH,CAAC,CAAC,CAAC;KACJ;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAhBD,4BAgBC;AAED,SAAS,QAAQ,CAAC,IAAS;IACzB,OAAO,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAClE,CAAC"}

14
node_modules/graphql-tools/dist/mock.d.ts generated vendored Normal file
View File

@@ -0,0 +1,14 @@
import { GraphQLSchema, GraphQLList, GraphQLResolveInfo, GraphQLFieldResolver } from 'graphql';
import { IMocks, IMockServer, IMockOptions, IMockTypeFn, ITypeDefinitions } from './Interfaces';
declare function mockServer(schema: GraphQLSchema | ITypeDefinitions, mocks: IMocks, preserveResolvers?: boolean): IMockServer;
declare function addMockFunctionsToSchema({ schema, mocks, preserveResolvers, }: IMockOptions): void;
declare class MockList {
private len;
private wrappedFunction;
constructor(len: number | number[], wrappedFunction?: GraphQLFieldResolver<any, any>);
mock(root: any, args: {
[key: string]: any;
}, context: any, info: GraphQLResolveInfo, fieldType: GraphQLList<any>, mockTypeFunc: IMockTypeFn): any[];
private randint;
}
export { addMockFunctionsToSchema, MockList, mockServer };

306
node_modules/graphql-tools/dist/mock.js generated vendored Normal file
View File

@@ -0,0 +1,306 @@
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
var uuid = require("uuid");
var makeExecutableSchema_1 = require("./makeExecutableSchema");
// This function wraps addMockFunctionsToSchema for more convenience
function mockServer(schema, mocks, preserveResolvers) {
if (preserveResolvers === void 0) { preserveResolvers = false; }
var mySchema;
if (!(schema instanceof graphql_1.GraphQLSchema)) {
// TODO: provide useful error messages here if this fails
mySchema = makeExecutableSchema_1.buildSchemaFromTypeDefinitions(schema);
}
else {
mySchema = schema;
}
addMockFunctionsToSchema({ schema: mySchema, mocks: mocks, preserveResolvers: preserveResolvers });
return { query: function (query, vars) { return graphql_1.graphql(mySchema, query, {}, {}, vars); } };
}
exports.mockServer = mockServer;
var defaultMockMap = new Map();
defaultMockMap.set('Int', function () { return Math.round(Math.random() * 200) - 100; });
defaultMockMap.set('Float', function () { return Math.random() * 200 - 100; });
defaultMockMap.set('String', function () { return 'Hello World'; });
defaultMockMap.set('Boolean', function () { return Math.random() > 0.5; });
defaultMockMap.set('ID', function () { return uuid.v4(); });
// TODO allow providing a seed such that lengths of list could be deterministic
// this could be done by using casual to get a random list length if the casual
// object is global.
function addMockFunctionsToSchema(_a) {
var schema = _a.schema, _b = _a.mocks, mocks = _b === void 0 ? {} : _b, _c = _a.preserveResolvers, preserveResolvers = _c === void 0 ? false : _c;
if (!schema) {
throw new Error('Must provide schema to mock');
}
if (!(schema instanceof graphql_1.GraphQLSchema)) {
throw new Error('Value at "schema" must be of type GraphQLSchema');
}
if (!isObject(mocks)) {
throw new Error('mocks must be of type Object');
}
// use Map internally, because that API is nicer.
var mockFunctionMap = new Map();
Object.keys(mocks).forEach(function (typeName) {
mockFunctionMap.set(typeName, mocks[typeName]);
});
mockFunctionMap.forEach(function (mockFunction, mockTypeName) {
if (typeof mockFunction !== 'function') {
throw new Error("mockFunctionMap[" + mockTypeName + "] must be a function");
}
});
var mockType = function (type, typeName, fieldName) {
// order of precendence for mocking:
// 1. if the object passed in already has fieldName, just use that
// --> if it's a function, that becomes your resolver
// --> if it's a value, the mock resolver will return that
// 2. if the nullableType is a list, recurse
// 2. if there's a mock defined for this typeName, that will be used
// 3. if there's no mock defined, use the default mocks for this type
return function (root, args, context, info) {
// nullability doesn't matter for the purpose of mocking.
var fieldType = graphql_1.getNullableType(type);
var namedFieldType = graphql_1.getNamedType(fieldType);
if (root && typeof root[fieldName] !== 'undefined') {
var result = void 0;
// if we're here, the field is already defined
if (typeof root[fieldName] === 'function') {
result = root[fieldName](root, args, context, info);
if (result instanceof MockList) {
result = result.mock(root, args, context, info, fieldType, mockType);
}
}
else {
result = root[fieldName];
}
// Now we merge the result with the default mock for this type.
// This allows overriding defaults while writing very little code.
if (mockFunctionMap.has(namedFieldType.name)) {
result = mergeMocks(mockFunctionMap
.get(namedFieldType.name)
.bind(null, root, args, context, info), result);
}
return result;
}
if (fieldType instanceof graphql_1.GraphQLList ||
fieldType instanceof graphql_1.GraphQLNonNull) {
return [
mockType(fieldType.ofType)(root, args, context, info),
mockType(fieldType.ofType)(root, args, context, info),
];
}
if (mockFunctionMap.has(fieldType.name) &&
!(fieldType instanceof graphql_1.GraphQLUnionType ||
fieldType instanceof graphql_1.GraphQLInterfaceType)) {
// the object passed doesn't have this field, so we apply the default mock
return mockFunctionMap.get(fieldType.name)(root, args, context, info);
}
if (fieldType instanceof graphql_1.GraphQLObjectType) {
// objects don't return actual data, we only need to mock scalars!
return {};
}
// if a mock function is provided for unionType or interfaceType, execute it to resolve the concrete type
// otherwise randomly pick a type from all implementation types
if (fieldType instanceof graphql_1.GraphQLUnionType ||
fieldType instanceof graphql_1.GraphQLInterfaceType) {
var implementationType = void 0;
if (mockFunctionMap.has(fieldType.name)) {
var interfaceMockObj = mockFunctionMap.get(fieldType.name)(root, args, context, info);
if (!interfaceMockObj || !interfaceMockObj.__typename) {
return Error("Please return a __typename in \"" + fieldType.name + "\"");
}
implementationType = schema.getType(interfaceMockObj.__typename);
}
else {
var possibleTypes = schema.getPossibleTypes(fieldType);
implementationType = getRandomElement(possibleTypes);
}
return Object.assign({ __typename: implementationType }, mockType(implementationType)(root, args, context, info));
}
if (fieldType instanceof graphql_1.GraphQLEnumType) {
return getRandomElement(fieldType.getValues()).value;
}
if (defaultMockMap.has(fieldType.name)) {
return defaultMockMap.get(fieldType.name)(root, args, context, info);
}
// if we get to here, we don't have a value, and we don't have a mock for this type,
// we could return undefined, but that would be hard to debug, so we throw instead.
// however, we returning it instead of throwing it, so preserveResolvers can handle the failures.
return Error("No mock defined for type \"" + fieldType.name + "\"");
};
};
makeExecutableSchema_1.forEachField(schema, function (field, typeName, fieldName) {
assignResolveType(field.type, preserveResolvers);
var mockResolver;
// we have to handle the root mutation and root query types differently,
// because no resolver is called at the root.
/* istanbul ignore next: Must provide schema DefinitionNode with query type or a type named Query. */
var isOnQueryType = schema.getQueryType() && schema.getQueryType().name === typeName;
var isOnMutationType = schema.getMutationType() && schema.getMutationType().name === typeName;
if (isOnQueryType || isOnMutationType) {
if (mockFunctionMap.has(typeName)) {
var rootMock_1 = mockFunctionMap.get(typeName);
// XXX: BUG in here, need to provide proper signature for rootMock.
if (typeof rootMock_1(undefined, {}, {}, {})[fieldName] === 'function') {
mockResolver = function (root, args, context, info) {
var updatedRoot = root || {}; // TODO: should we clone instead?
updatedRoot[fieldName] = rootMock_1(root, args, context, info)[fieldName];
// XXX this is a bit of a hack to still use mockType, which
// lets you mock lists etc. as well
// otherwise we could just set field.resolve to rootMock()[fieldName]
// it's like pretending there was a resolve function that ran before
// the root resolve function.
return mockType(field.type, typeName, fieldName)(updatedRoot, args, context, info);
};
}
}
}
if (!mockResolver) {
mockResolver = mockType(field.type, typeName, fieldName);
}
if (!preserveResolvers || !field.resolve) {
field.resolve = mockResolver;
}
else {
var oldResolver_1 = field.resolve;
field.resolve = function (rootObject, args, context, info) {
return Promise.all([
mockResolver(rootObject, args, context, info),
oldResolver_1(rootObject, args, context, info),
]).then(function (values) {
var mockedValue = values[0], resolvedValue = values[1];
// In case we couldn't mock
if (mockedValue instanceof Error) {
// only if value was not resolved, populate the error.
if (undefined === resolvedValue) {
throw mockedValue;
}
return resolvedValue;
}
if (resolvedValue instanceof Date && mockedValue instanceof Date) {
return undefined !== resolvedValue ? resolvedValue : mockedValue;
}
if (isObject(mockedValue) && isObject(resolvedValue)) {
// Object.assign() won't do here, as we need to all properties, including
// the non-enumerable ones and defined using Object.defineProperty
var emptyObject = Object.create(Object.getPrototypeOf(resolvedValue));
return copyOwnProps(emptyObject, resolvedValue, mockedValue);
}
return undefined !== resolvedValue ? resolvedValue : mockedValue;
});
};
}
});
}
exports.addMockFunctionsToSchema = addMockFunctionsToSchema;
function isObject(thing) {
return thing === Object(thing) && !Array.isArray(thing);
}
// returns a random element from that ary
function getRandomElement(ary) {
var sample = Math.floor(Math.random() * ary.length);
return ary[sample];
}
function mergeObjects(a, b) {
return Object.assign(a, b);
}
function copyOwnPropsIfNotPresent(target, source) {
Object.getOwnPropertyNames(source).forEach(function (prop) {
if (!Object.getOwnPropertyDescriptor(target, prop)) {
Object.defineProperty(target, prop, Object.getOwnPropertyDescriptor(source, prop));
}
});
}
function copyOwnProps(target) {
var sources = [];
for (var _i = 1; _i < arguments.length; _i++) {
sources[_i - 1] = arguments[_i];
}
sources.forEach(function (source) {
var chain = source;
while (chain) {
copyOwnPropsIfNotPresent(target, chain);
chain = Object.getPrototypeOf(chain);
}
});
return target;
}
// takes either an object or a (possibly nested) array
// and completes the customMock object with any fields
// defined on genericMock
// only merges objects or arrays. Scalars are returned as is
function mergeMocks(genericMockFunction, customMock) {
if (Array.isArray(customMock)) {
return customMock.map(function (el) { return mergeMocks(genericMockFunction, el); });
}
if (isObject(customMock)) {
return mergeObjects(genericMockFunction(), customMock);
}
return customMock;
}
function getResolveType(namedFieldType) {
if (namedFieldType instanceof graphql_1.GraphQLInterfaceType ||
namedFieldType instanceof graphql_1.GraphQLUnionType) {
return namedFieldType.resolveType;
}
else {
return undefined;
}
}
function assignResolveType(type, preserveResolvers) {
var fieldType = graphql_1.getNullableType(type);
var namedFieldType = graphql_1.getNamedType(fieldType);
var oldResolveType = getResolveType(namedFieldType);
if (preserveResolvers && oldResolveType && oldResolveType.length) {
return;
}
if (namedFieldType instanceof graphql_1.GraphQLUnionType ||
namedFieldType instanceof graphql_1.GraphQLInterfaceType) {
// the default `resolveType` always returns null. We add a fallback
// resolution that works with how unions and interface are mocked
namedFieldType.resolveType = function (data, context, info) {
return info.schema.getType(data.__typename);
};
}
}
var MockList = /** @class */ (function () {
// wrappedFunction can return another MockList or a value
function MockList(len, wrappedFunction) {
this.len = len;
if (typeof wrappedFunction !== 'undefined') {
if (typeof wrappedFunction !== 'function') {
throw new Error('Second argument to MockList must be a function or undefined');
}
this.wrappedFunction = wrappedFunction;
}
}
MockList.prototype.mock = function (root, args, context, info, fieldType, mockTypeFunc) {
var arr;
if (Array.isArray(this.len)) {
arr = new Array(this.randint(this.len[0], this.len[1]));
}
else {
arr = new Array(this.len);
}
for (var i = 0; i < arr.length; i++) {
if (typeof this.wrappedFunction === 'function') {
var res = this.wrappedFunction(root, args, context, info);
if (res instanceof MockList) {
var nullableType = graphql_1.getNullableType(fieldType.ofType);
arr[i] = res.mock(root, args, context, info, nullableType, mockTypeFunc);
}
else {
arr[i] = res;
}
}
else {
arr[i] = mockTypeFunc(fieldType.ofType)(root, args, context, info);
}
}
return arr;
};
MockList.prototype.randint = function (low, high) {
return Math.floor(Math.random() * (high - low + 1) + low);
};
return MockList;
}());
exports.MockList = MockList;
//# sourceMappingURL=mock.js.map

1
node_modules/graphql-tools/dist/mock.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

62
node_modules/graphql-tools/dist/schemaVisitor.d.ts generated vendored Normal file
View File

@@ -0,0 +1,62 @@
import { GraphQLArgument, GraphQLDirective, GraphQLEnumType, GraphQLEnumValue, GraphQLField, GraphQLInputField, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLNamedType, GraphQLObjectType, GraphQLScalarType, GraphQLSchema, GraphQLUnionType } from 'graphql';
export declare type VisitableSchemaType = GraphQLSchema | GraphQLObjectType | GraphQLInterfaceType | GraphQLInputObjectType | GraphQLNamedType | GraphQLScalarType | GraphQLField<any, any> | GraphQLArgument | GraphQLUnionType | GraphQLEnumType | GraphQLEnumValue | GraphQLInputField;
export declare abstract class SchemaVisitor {
schema: GraphQLSchema;
static implementsVisitorMethod(methodName: string): boolean;
visitSchema(schema: GraphQLSchema): void;
visitScalar(scalar: GraphQLScalarType): GraphQLScalarType | void | null;
visitObject(object: GraphQLObjectType): GraphQLObjectType | void | null;
visitFieldDefinition(field: GraphQLField<any, any>, details: {
objectType: GraphQLObjectType | GraphQLInterfaceType;
}): GraphQLField<any, any> | void | null;
visitArgumentDefinition(argument: GraphQLArgument, details: {
field: GraphQLField<any, any>;
objectType: GraphQLObjectType | GraphQLInterfaceType;
}): GraphQLArgument | void | null;
visitInterface(iface: GraphQLInterfaceType): GraphQLInterfaceType | void | null;
visitUnion(union: GraphQLUnionType): GraphQLUnionType | void | null;
visitEnum(type: GraphQLEnumType): GraphQLEnumType | void | null;
visitEnumValue(value: GraphQLEnumValue, details: {
enumType: GraphQLEnumType;
}): GraphQLEnumValue | void | null;
visitInputObject(object: GraphQLInputObjectType): GraphQLInputObjectType | void | null;
visitInputFieldDefinition(field: GraphQLInputField, details: {
objectType: GraphQLInputObjectType;
}): GraphQLInputField | void | null;
}
export declare function visitSchema(schema: GraphQLSchema, visitorSelector: (type: VisitableSchemaType, methodName: string) => SchemaVisitor[]): GraphQLSchema;
export declare function healSchema(schema: GraphQLSchema): GraphQLSchema;
export declare class SchemaDirectiveVisitor extends SchemaVisitor {
name: string;
args: {
[name: string]: any;
};
visitedType: VisitableSchemaType;
context: {
[key: string]: any;
};
static getDirectiveDeclaration(directiveName: string, schema: GraphQLSchema): GraphQLDirective;
static visitSchemaDirectives(schema: GraphQLSchema, directiveVisitors: {
[directiveName: string]: typeof SchemaDirectiveVisitor;
}, context?: {
[key: string]: any;
}): {
[directiveName: string]: SchemaDirectiveVisitor[];
};
protected static getDeclaredDirectives(schema: GraphQLSchema, directiveVisitors: {
[directiveName: string]: typeof SchemaDirectiveVisitor;
}): {
[directiveName: string]: GraphQLDirective;
};
protected constructor(config: {
name: string;
args: {
[name: string]: any;
};
visitedType: VisitableSchemaType;
schema: GraphQLSchema;
context: {
[key: string]: any;
};
});
}

587
node_modules/graphql-tools/dist/schemaVisitor.js generated vendored Normal file
View File

@@ -0,0 +1,587 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __spreadArrays = (this && this.__spreadArrays) || function () {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
var values_1 = require("graphql/execution/values");
var hasOwn = Object.prototype.hasOwnProperty;
// Abstract base class of any visitor implementation, defining the available
// visitor methods along with their parameter types, and providing a static
// helper function for determining whether a subclass implements a given
// visitor method, as opposed to inheriting one of the stubs defined here.
var SchemaVisitor = /** @class */ (function () {
function SchemaVisitor() {
}
// Determine if this SchemaVisitor (sub)class implements a particular
// visitor method.
SchemaVisitor.implementsVisitorMethod = function (methodName) {
if (!methodName.startsWith('visit')) {
return false;
}
var method = this.prototype[methodName];
if (typeof method !== 'function') {
return false;
}
if (this === SchemaVisitor) {
// The SchemaVisitor class implements every visitor method.
return true;
}
var stub = SchemaVisitor.prototype[methodName];
if (method === stub) {
// If this.prototype[methodName] was just inherited from SchemaVisitor,
// then this class does not really implement the method.
return false;
}
return true;
};
// Concrete subclasses of SchemaVisitor should override one or more of these
// visitor methods, in order to express their interest in handling certain
// schema types/locations. Each method may return null to remove the given
// type from the schema, a non-null value of the same type to update the
// type in the schema, or nothing to leave the type as it was.
/* tslint:disable:no-empty */
SchemaVisitor.prototype.visitSchema = function (schema) { };
SchemaVisitor.prototype.visitScalar = function (scalar) { };
SchemaVisitor.prototype.visitObject = function (object) { };
SchemaVisitor.prototype.visitFieldDefinition = function (field, details) { };
SchemaVisitor.prototype.visitArgumentDefinition = function (argument, details) { };
SchemaVisitor.prototype.visitInterface = function (iface) { };
SchemaVisitor.prototype.visitUnion = function (union) { };
SchemaVisitor.prototype.visitEnum = function (type) { };
SchemaVisitor.prototype.visitEnumValue = function (value, details) { };
SchemaVisitor.prototype.visitInputObject = function (object) { };
SchemaVisitor.prototype.visitInputFieldDefinition = function (field, details) { };
return SchemaVisitor;
}());
exports.SchemaVisitor = SchemaVisitor;
// Generic function for visiting GraphQLSchema objects.
function visitSchema(schema,
// To accommodate as many different visitor patterns as possible, the
// visitSchema function does not simply accept a single instance of the
// SchemaVisitor class, but instead accepts a function that takes the
// current VisitableSchemaType object and the name of a visitor method and
// returns an array of SchemaVisitor instances that implement the visitor
// method and have an interest in handling the given VisitableSchemaType
// object. In the simplest case, this function can always return an array
// containing a single visitor object, without even looking at the type or
// methodName parameters. In other cases, this function might sometimes
// return an empty array to indicate there are no visitors that should be
// applied to the given VisitableSchemaType object. For an example of a
// visitor pattern that benefits from this abstraction, see the
// SchemaDirectiveVisitor class below.
visitorSelector) {
// Helper function that calls visitorSelector and applies the resulting
// visitors to the given type, with arguments [type, ...args].
function callMethod(methodName, type) {
var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
args[_i - 2] = arguments[_i];
}
visitorSelector(type, methodName).every(function (visitor) {
var newType = visitor[methodName].apply(visitor, __spreadArrays([type], args));
if (typeof newType === 'undefined') {
// Keep going without modifying type.
return true;
}
if (methodName === 'visitSchema' ||
type instanceof graphql_1.GraphQLSchema) {
throw new Error("Method " + methodName + " cannot replace schema with " + newType);
}
if (newType === null) {
// Stop the loop and return null form callMethod, which will cause
// the type to be removed from the schema.
type = null;
return false;
}
// Update type to the new type returned by the visitor method, so that
// later directives will see the new type, and callMethod will return
// the final type.
type = newType;
return true;
});
// If there were no directives for this type object, or if all visitor
// methods returned nothing, type will be returned unmodified.
return type;
}
// Recursive helper function that calls any appropriate visitor methods for
// each object in the schema, then traverses the object's children (if any).
function visit(type) {
if (type instanceof graphql_1.GraphQLSchema) {
// Unlike the other types, the root GraphQLSchema object cannot be
// replaced by visitor methods, because that would make life very hard
// for SchemaVisitor subclasses that rely on the original schema object.
callMethod('visitSchema', type);
updateEachKey(type.getTypeMap(), function (namedType, typeName) {
if (!typeName.startsWith('__')) {
// Call visit recursively to let it determine which concrete
// subclass of GraphQLNamedType we found in the type map. Because
// we're using updateEachKey, the result of visit(namedType) may
// cause the type to be removed or replaced.
return visit(namedType);
}
});
return type;
}
if (type instanceof graphql_1.GraphQLObjectType) {
// Note that callMethod('visitObject', type) may not actually call any
// methods, if there are no @directive annotations associated with this
// type, or if this SchemaDirectiveVisitor subclass does not override
// the visitObject method.
var newObject = callMethod('visitObject', type);
if (newObject) {
visitFields(newObject);
}
return newObject;
}
if (type instanceof graphql_1.GraphQLInterfaceType) {
var newInterface = callMethod('visitInterface', type);
if (newInterface) {
visitFields(newInterface);
}
return newInterface;
}
if (type instanceof graphql_1.GraphQLInputObjectType) {
var newInputObject_1 = callMethod('visitInputObject', type);
if (newInputObject_1) {
updateEachKey(newInputObject_1.getFields(), function (field) {
// Since we call a different method for input object fields, we
// can't reuse the visitFields function here.
return callMethod('visitInputFieldDefinition', field, {
objectType: newInputObject_1,
});
});
}
return newInputObject_1;
}
if (type instanceof graphql_1.GraphQLScalarType) {
return callMethod('visitScalar', type);
}
if (type instanceof graphql_1.GraphQLUnionType) {
return callMethod('visitUnion', type);
}
if (type instanceof graphql_1.GraphQLEnumType) {
var newEnum_1 = callMethod('visitEnum', type);
if (newEnum_1) {
updateEachKey(newEnum_1.getValues(), function (value) {
return callMethod('visitEnumValue', value, {
enumType: newEnum_1,
});
});
}
return newEnum_1;
}
throw new Error("Unexpected schema type: " + type);
}
function visitFields(type) {
updateEachKey(type.getFields(), function (field) {
// It would be nice if we could call visit(field) recursively here, but
// GraphQLField is merely a type, not a value that can be detected using
// an instanceof check, so we have to visit the fields in this lexical
// context, so that TypeScript can validate the call to
// visitFieldDefinition.
var newField = callMethod('visitFieldDefinition', field, {
// While any field visitor needs a reference to the field object, some
// field visitors may also need to know the enclosing (parent) type,
// perhaps to determine if the parent is a GraphQLObjectType or a
// GraphQLInterfaceType. To obtain a reference to the parent, a
// visitor method can have a second parameter, which will be an object
// with an .objectType property referring to the parent.
objectType: type,
});
if (newField && newField.args) {
updateEachKey(newField.args, function (arg) {
return callMethod('visitArgumentDefinition', arg, {
// Like visitFieldDefinition, visitArgumentDefinition takes a
// second parameter that provides additional context, namely the
// parent .field and grandparent .objectType. Remember that the
// current GraphQLSchema is always available via this.schema.
field: newField,
objectType: type,
});
});
}
return newField;
});
}
visit(schema);
// Return the original schema for convenience, even though it cannot have
// been replaced or removed by the code above.
return schema;
}
exports.visitSchema = visitSchema;
// Update any references to named schema types that disagree with the named
// types found in schema.getTypeMap().
function healSchema(schema) {
heal(schema);
return schema;
function heal(type) {
if (type instanceof graphql_1.GraphQLSchema) {
var originalTypeMap_1 = type.getTypeMap();
var actualNamedTypeMap_1 = Object.create(null);
// If any of the .name properties of the GraphQLNamedType objects in
// schema.getTypeMap() have changed, the keys of the type map need to
// be updated accordingly.
each(originalTypeMap_1, function (namedType, typeName) {
if (typeName.startsWith('__')) {
return;
}
var actualName = namedType.name;
if (actualName.startsWith('__')) {
return;
}
if (hasOwn.call(actualNamedTypeMap_1, actualName)) {
throw new Error("Duplicate schema type name " + actualName);
}
actualNamedTypeMap_1[actualName] = namedType;
// Note: we are deliberately leaving namedType in the schema by its
// original name (which might be different from actualName), so that
// references by that name can be healed.
});
// Now add back every named type by its actual name.
each(actualNamedTypeMap_1, function (namedType, typeName) {
originalTypeMap_1[typeName] = namedType;
});
// Directive declaration argument types can refer to named types.
each(type.getDirectives(), function (decl) {
if (decl.args) {
each(decl.args, function (arg) {
arg.type = healType(arg.type);
});
}
});
each(originalTypeMap_1, function (namedType, typeName) {
if (!typeName.startsWith('__')) {
heal(namedType);
}
});
updateEachKey(originalTypeMap_1, function (namedType, typeName) {
// Dangling references to renamed types should remain in the schema
// during healing, but must be removed now, so that the following
// invariant holds for all names: schema.getType(name).name === name
if (!typeName.startsWith('__') &&
!hasOwn.call(actualNamedTypeMap_1, typeName)) {
return null;
}
});
}
else if (type instanceof graphql_1.GraphQLObjectType) {
healFields(type);
each(type.getInterfaces(), function (iface) { return heal(iface); });
}
else if (type instanceof graphql_1.GraphQLInterfaceType) {
healFields(type);
}
else if (type instanceof graphql_1.GraphQLInputObjectType) {
each(type.getFields(), function (field) {
field.type = healType(field.type);
});
}
else if (type instanceof graphql_1.GraphQLScalarType) {
// Nothing to do.
}
else if (type instanceof graphql_1.GraphQLUnionType) {
updateEachKey(type.getTypes(), function (t) { return healType(t); });
}
else if (type instanceof graphql_1.GraphQLEnumType) {
// Nothing to do.
}
else {
throw new Error("Unexpected schema type: " + type);
}
}
function healFields(type) {
each(type.getFields(), function (field) {
field.type = healType(field.type);
if (field.args) {
each(field.args, function (arg) {
arg.type = healType(arg.type);
});
}
});
}
function healType(type) {
// Unwrap the two known wrapper types
if (type instanceof graphql_1.GraphQLList) {
type = new graphql_1.GraphQLList(healType(type.ofType));
}
else if (type instanceof graphql_1.GraphQLNonNull) {
type = new graphql_1.GraphQLNonNull(healType(type.ofType));
}
else if (graphql_1.isNamedType(type)) {
// If a type annotation on a field or an argument or a union member is
// any `GraphQLNamedType` with a `name`, then it must end up identical
// to `schema.getType(name)`, since `schema.getTypeMap()` is the source
// of truth for all named schema types.
var namedType = type;
var officialType = schema.getType(namedType.name);
if (officialType && namedType !== officialType) {
return officialType;
}
}
return type;
}
}
exports.healSchema = healSchema;
// This class represents a reusable implementation of a @directive that may
// appear in a GraphQL schema written in Schema Definition Language.
//
// By overriding one or more visit{Object,Union,...} methods, a subclass
// registers interest in certain schema types, such as GraphQLObjectType,
// GraphQLUnionType, etc. When SchemaDirectiveVisitor.visitSchemaDirectives is
// called with a GraphQLSchema object and a map of visitor subclasses, the
// overidden methods of those subclasses allow the visitors to obtain
// references to any type objects that have @directives attached to them,
// enabling visitors to inspect or modify the schema as appropriate.
//
// For example, if a directive called @rest(url: "...") appears after a field
// definition, a SchemaDirectiveVisitor subclass could provide meaning to that
// directive by overriding the visitFieldDefinition method (which receives a
// GraphQLField parameter), and then the body of that visitor method could
// manipulate the field's resolver function to fetch data from a REST endpoint
// described by the url argument passed to the @rest directive:
//
// const typeDefs = `
// type Query {
// people: [Person] @rest(url: "/api/v1/people")
// }`;
//
// const schema = makeExecutableSchema({ typeDefs });
//
// SchemaDirectiveVisitor.visitSchemaDirectives(schema, {
// rest: class extends SchemaDirectiveVisitor {
// public visitFieldDefinition(field: GraphQLField<any, any>) {
// const { url } = this.args;
// field.resolve = () => fetch(url);
// }
// }
// });
//
// The subclass in this example is defined as an anonymous class expression,
// for brevity. A truly reusable SchemaDirectiveVisitor would most likely be
// defined in a library using a named class declaration, and then exported for
// consumption by other modules and packages.
//
// See below for a complete list of overridable visitor methods, their
// parameter types, and more details about the properties exposed by instances
// of the SchemaDirectiveVisitor class.
var SchemaDirectiveVisitor = /** @class */ (function (_super) {
__extends(SchemaDirectiveVisitor, _super);
// Mark the constructor protected to enforce passing SchemaDirectiveVisitor
// subclasses (not instances) to visitSchemaDirectives.
function SchemaDirectiveVisitor(config) {
var _this = _super.call(this) || this;
_this.name = config.name;
_this.args = config.args;
_this.visitedType = config.visitedType;
_this.schema = config.schema;
_this.context = config.context;
return _this;
}
// Override this method to return a custom GraphQLDirective (or modify one
// already present in the schema) to enforce argument types, provide default
// argument values, or specify schema locations where this @directive may
// appear. By default, any declaration found in the schema will be returned.
SchemaDirectiveVisitor.getDirectiveDeclaration = function (directiveName, schema) {
return schema.getDirective(directiveName);
};
// Call SchemaDirectiveVisitor.visitSchemaDirectives to visit every
// @directive in the schema and create an appropriate SchemaDirectiveVisitor
// instance to visit the object decorated by the @directive.
SchemaDirectiveVisitor.visitSchemaDirectives = function (schema, directiveVisitors,
// Optional context object that will be available to all visitor instances
// via this.context. Defaults to an empty null-prototype object.
context) {
if (context === void 0) { context = Object.create(null); }
// If the schema declares any directives for public consumption, record
// them here so that we can properly coerce arguments when/if we encounter
// an occurrence of the directive while walking the schema below.
var declaredDirectives = this.getDeclaredDirectives(schema, directiveVisitors);
// Map from directive names to lists of SchemaDirectiveVisitor instances
// created while visiting the schema.
var createdVisitors = Object.create(null);
Object.keys(directiveVisitors).forEach(function (directiveName) {
createdVisitors[directiveName] = [];
});
function visitorSelector(type, methodName) {
var visitors = [];
var directiveNodes = type.astNode && type.astNode.directives;
if (!directiveNodes) {
return visitors;
}
directiveNodes.forEach(function (directiveNode) {
var directiveName = directiveNode.name.value;
if (!hasOwn.call(directiveVisitors, directiveName)) {
return;
}
var visitorClass = directiveVisitors[directiveName];
// Avoid creating visitor objects if visitorClass does not override
// the visitor method named by methodName.
if (!visitorClass.implementsVisitorMethod(methodName)) {
return;
}
var decl = declaredDirectives[directiveName];
var args;
if (decl) {
// If this directive was explicitly declared, use the declared
// argument types (and any default values) to check, coerce, and/or
// supply default values for the given arguments.
args = values_1.getArgumentValues(decl, directiveNode);
}
else {
// If this directive was not explicitly declared, just convert the
// argument nodes to their corresponding JavaScript values.
args = Object.create(null);
directiveNode.arguments.forEach(function (arg) {
args[arg.name.value] = valueFromASTUntyped(arg.value);
});
}
// As foretold in comments near the top of the visitSchemaDirectives
// method, this is where instances of the SchemaDirectiveVisitor class
// get created and assigned names. While subclasses could override the
// constructor method, the constructor is marked as protected, so
// these are the only arguments that will ever be passed.
visitors.push(new visitorClass({
name: directiveName,
args: args,
visitedType: type,
schema: schema,
context: context,
}));
});
if (visitors.length > 0) {
visitors.forEach(function (visitor) {
createdVisitors[visitor.name].push(visitor);
});
}
return visitors;
}
visitSchema(schema, visitorSelector);
// Automatically update any references to named schema types replaced
// during the traversal, so implementors don't have to worry about that.
healSchema(schema);
return createdVisitors;
};
SchemaDirectiveVisitor.getDeclaredDirectives = function (schema, directiveVisitors) {
var declaredDirectives = Object.create(null);
each(schema.getDirectives(), function (decl) {
declaredDirectives[decl.name] = decl;
});
// If the visitor subclass overrides getDirectiveDeclaration, and it
// returns a non-null GraphQLDirective, use that instead of any directive
// declared in the schema itself. Reasoning: if a SchemaDirectiveVisitor
// goes to the trouble of implementing getDirectiveDeclaration, it should
// be able to rely on that implementation.
each(directiveVisitors, function (visitorClass, directiveName) {
var decl = visitorClass.getDirectiveDeclaration(directiveName, schema);
if (decl) {
declaredDirectives[directiveName] = decl;
}
});
each(declaredDirectives, function (decl, name) {
if (!hasOwn.call(directiveVisitors, name)) {
// SchemaDirectiveVisitors.visitSchemaDirectives might be called
// multiple times with partial directiveVisitors maps, so it's not
// necessarily an error for directiveVisitors to be missing an
// implementation of a directive that was declared in the schema.
return;
}
var visitorClass = directiveVisitors[name];
each(decl.locations, function (loc) {
var visitorMethodName = directiveLocationToVisitorMethodName(loc);
if (SchemaVisitor.implementsVisitorMethod(visitorMethodName) &&
!visitorClass.implementsVisitorMethod(visitorMethodName)) {
// While visitor subclasses may implement extra visitor methods,
// it's definitely a mistake if the GraphQLDirective declares itself
// applicable to certain schema locations, and the visitor subclass
// does not implement all the corresponding methods.
throw new Error("SchemaDirectiveVisitor for @" + name + " must implement " + visitorMethodName + " method");
}
});
});
return declaredDirectives;
};
return SchemaDirectiveVisitor;
}(SchemaVisitor));
exports.SchemaDirectiveVisitor = SchemaDirectiveVisitor;
// Convert a string like "FIELD_DEFINITION" to "visitFieldDefinition".
function directiveLocationToVisitorMethodName(loc) {
return 'visit' + loc.replace(/([^_]*)_?/g, function (wholeMatch, part) {
return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
});
}
function each(arrayOrObject, callback) {
Object.keys(arrayOrObject).forEach(function (key) {
callback(arrayOrObject[key], key);
});
}
// A more powerful version of each that has the ability to replace or remove
// array or object keys.
function updateEachKey(arrayOrObject,
// The callback can return nothing to leave the key untouched, null to remove
// the key from the array or object, or a non-null V to replace the value.
callback) {
var deletedCount = 0;
Object.keys(arrayOrObject).forEach(function (key) {
var result = callback(arrayOrObject[key], key);
if (typeof result === 'undefined') {
return;
}
if (result === null) {
delete arrayOrObject[key];
deletedCount++;
return;
}
arrayOrObject[key] = result;
});
if (deletedCount > 0 && Array.isArray(arrayOrObject)) {
// Remove any holes from the array due to deleted elements.
arrayOrObject.splice(0).forEach(function (elem) {
arrayOrObject.push(elem);
});
}
}
// Similar to the graphql-js function of the same name, slightly simplified:
// https://github.com/graphql/graphql-js/blob/master/src/utilities/valueFromASTUntyped.js
function valueFromASTUntyped(valueNode) {
switch (valueNode.kind) {
case graphql_1.Kind.NULL:
return null;
case graphql_1.Kind.INT:
return parseInt(valueNode.value, 10);
case graphql_1.Kind.FLOAT:
return parseFloat(valueNode.value);
case graphql_1.Kind.STRING:
case graphql_1.Kind.ENUM:
case graphql_1.Kind.BOOLEAN:
return valueNode.value;
case graphql_1.Kind.LIST:
return valueNode.values.map(valueFromASTUntyped);
case graphql_1.Kind.OBJECT:
var obj_1 = Object.create(null);
valueNode.fields.forEach(function (field) {
obj_1[field.name.value] = valueFromASTUntyped(field.value);
});
return obj_1;
/* istanbul ignore next */
default:
throw new Error('Unexpected value kind: ' + valueNode.kind);
}
}
//# sourceMappingURL=schemaVisitor.js.map

1
node_modules/graphql-tools/dist/schemaVisitor.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

3
node_modules/graphql-tools/dist/stitching/defaultMergedResolver.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
import { GraphQLFieldResolver } from 'graphql';
declare const defaultMergedResolver: GraphQLFieldResolver<any, any>;
export default defaultMergedResolver;

32
node_modules/graphql-tools/dist/stitching/defaultMergedResolver.js generated vendored Normal file
View File

@@ -0,0 +1,32 @@
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
var error_1 = require("graphql/error");
var errors_1 = require("./errors");
var getResponseKeyFromInfo_1 = require("./getResponseKeyFromInfo");
// Resolver that knows how to:
// a) handle aliases for proxied schemas
// b) handle errors from proxied schemas
var defaultMergedResolver = function (parent, args, context, info) {
if (!parent) {
return null;
}
var responseKey = getResponseKeyFromInfo_1.getResponseKeyFromInfo(info);
var errorResult = errors_1.getErrorsFromParent(parent, responseKey);
if (errorResult.kind === 'OWN') {
throw error_1.locatedError(new Error(errorResult.error.message), info.fieldNodes, graphql_1.responsePathAsArray(info.path));
}
var result = parent[responseKey];
if (result == null) {
result = parent[info.fieldName];
}
// subscription result mapping
if (!result && parent.data && parent.data[responseKey]) {
result = parent.data[responseKey];
}
if (errorResult.errors) {
result = errors_1.annotateWithChildrenErrors(result, errorResult.errors);
}
return result;
};
exports.default = defaultMergedResolver;
//# sourceMappingURL=defaultMergedResolver.js.map

1
node_modules/graphql-tools/dist/stitching/defaultMergedResolver.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"defaultMergedResolver.js","sourceRoot":"","sources":["../../src/stitching/defaultMergedResolver.ts"],"names":[],"mappings":";AAAA,mCAAoE;AACpE,uCAA6C;AAC7C,mCAA2E;AAC3E,mEAAkE;AAElE,8BAA8B;AAC9B,wCAAwC;AACxC,wCAAwC;AACxC,IAAM,qBAAqB,GAAmC,UAAC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI;IACxF,IAAI,CAAC,MAAM,EAAE;QACX,OAAO,IAAI,CAAC;KACb;IAED,IAAM,WAAW,GAAG,+CAAsB,CAAC,IAAI,CAAC,CAAC;IACjD,IAAM,WAAW,GAAG,4BAAmB,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAE7D,IAAI,WAAW,CAAC,IAAI,KAAK,KAAK,EAAE;QAC9B,MAAM,oBAAY,CAAC,IAAI,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,6BAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;KAC3G;IAED,IAAI,MAAM,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;IAEjC,IAAI,MAAM,IAAI,IAAI,EAAE;QAClB,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;KACjC;IAED,8BAA8B;IAC9B,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;QACtD,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;KACnC;IAED,IAAI,WAAW,CAAC,MAAM,EAAE;QACtB,MAAM,GAAG,mCAA0B,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;KACjE;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,kBAAe,qBAAqB,CAAC"}

3
node_modules/graphql-tools/dist/stitching/delegateToSchema.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
import { GraphQLSchema } from 'graphql';
import { IDelegateToSchemaOptions } from '../Interfaces';
export default function delegateToSchema(options: IDelegateToSchemaOptions | GraphQLSchema, ...args: any[]): Promise<any>;

171
node_modules/graphql-tools/dist/stitching/delegateToSchema.js generated vendored Normal file
View File

@@ -0,0 +1,171 @@
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __spreadArrays = (this && this.__spreadArrays) || function () {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
var transforms_1 = require("../transforms/transforms");
var AddArgumentsAsVariables_1 = require("../transforms/AddArgumentsAsVariables");
var FilterToSchema_1 = require("../transforms/FilterToSchema");
var AddTypenameToAbstract_1 = require("../transforms/AddTypenameToAbstract");
var CheckResultAndHandleErrors_1 = require("../transforms/CheckResultAndHandleErrors");
var mapAsyncIterator_1 = require("./mapAsyncIterator");
var ExpandAbstractTypes_1 = require("../transforms/ExpandAbstractTypes");
var ReplaceFieldWithFragment_1 = require("../transforms/ReplaceFieldWithFragment");
var ConvertEnumResponse_1 = require("../transforms/ConvertEnumResponse");
function delegateToSchema(options) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
if (options instanceof graphql_1.GraphQLSchema) {
throw new Error('Passing positional arguments to delegateToSchema is a deprecated. ' +
'Please pass named parameters instead.');
}
return delegateToSchemaImplementation(options);
}
exports.default = delegateToSchema;
function delegateToSchemaImplementation(options) {
return __awaiter(this, void 0, void 0, function () {
var info, _a, args, operation, rawDocument, rawRequest, transforms, processedRequest, errors, _b, executionResult;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
info = options.info, _a = options.args, args = _a === void 0 ? {} : _a;
operation = options.operation || info.operation.operation;
rawDocument = createDocument(options.fieldName, operation, info.fieldNodes, Object.keys(info.fragments).map(function (fragmentName) { return info.fragments[fragmentName]; }), info.operation.variableDefinitions, info.operation.name);
rawRequest = {
document: rawDocument,
variables: info.variableValues,
};
transforms = __spreadArrays((options.transforms || []), [
new ExpandAbstractTypes_1.default(info.schema, options.schema),
]);
if (info.mergeInfo && info.mergeInfo.fragments) {
transforms.push(new ReplaceFieldWithFragment_1.default(options.schema, info.mergeInfo.fragments));
}
transforms = transforms.concat([
new AddArgumentsAsVariables_1.default(options.schema, args),
new FilterToSchema_1.default(options.schema),
new AddTypenameToAbstract_1.default(options.schema),
new CheckResultAndHandleErrors_1.default(info, options.fieldName),
]);
if (graphql_1.isEnumType(options.info.returnType)) {
transforms = transforms.concat(new ConvertEnumResponse_1.default(options.info.returnType));
}
processedRequest = transforms_1.applyRequestTransforms(rawRequest, transforms);
if (!options.skipValidation) {
errors = graphql_1.validate(options.schema, processedRequest.document);
if (errors.length > 0) {
throw errors;
}
}
if (!(operation === 'query' || operation === 'mutation')) return [3 /*break*/, 2];
_b = transforms_1.applyResultTransforms;
return [4 /*yield*/, graphql_1.execute(options.schema, processedRequest.document, info.rootValue, options.context, processedRequest.variables)];
case 1: return [2 /*return*/, _b.apply(void 0, [_c.sent(),
transforms])];
case 2:
if (!(operation === 'subscription')) return [3 /*break*/, 4];
return [4 /*yield*/, graphql_1.subscribe(options.schema, processedRequest.document, info.rootValue, options.context, processedRequest.variables)];
case 3:
executionResult = (_c.sent());
// "subscribe" to the subscription result and map the result through the transforms
return [2 /*return*/, mapAsyncIterator_1.default(executionResult, function (result) {
var _a;
var transformedResult = transforms_1.applyResultTransforms(result, transforms);
var subscriptionKey = Object.keys(result.data)[0];
// for some reason the returned transformedResult needs to be nested inside the root subscription field
// does not work otherwise...
return _a = {},
_a[subscriptionKey] = transformedResult,
_a;
})];
case 4: return [2 /*return*/];
}
});
});
}
function createDocument(targetField, targetOperation, originalSelections, fragments, variables, operationName) {
var selections = [];
var args = [];
originalSelections.forEach(function (field) {
var fieldSelections = field.selectionSet
? field.selectionSet.selections
: [];
selections = selections.concat(fieldSelections);
args = args.concat(field.arguments || []);
});
var selectionSet = null;
if (selections.length > 0) {
selectionSet = {
kind: graphql_1.Kind.SELECTION_SET,
selections: selections,
};
}
var rootField = {
kind: graphql_1.Kind.FIELD,
alias: null,
arguments: args,
selectionSet: selectionSet,
name: {
kind: graphql_1.Kind.NAME,
value: targetField,
},
};
var rootSelectionSet = {
kind: graphql_1.Kind.SELECTION_SET,
selections: [rootField],
};
var operationDefinition = {
kind: graphql_1.Kind.OPERATION_DEFINITION,
operation: targetOperation,
variableDefinitions: variables,
selectionSet: rootSelectionSet,
name: operationName,
};
return {
kind: graphql_1.Kind.DOCUMENT,
definitions: __spreadArrays([operationDefinition], fragments),
};
}
//# sourceMappingURL=delegateToSchema.js.map

1
node_modules/graphql-tools/dist/stitching/delegateToSchema.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"delegateToSchema.js","sourceRoot":"","sources":["../../src/stitching/delegateToSchema.ts"],"names":[],"mappings":"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"}

11
node_modules/graphql-tools/dist/stitching/errors.d.ts generated vendored Normal file
View File

@@ -0,0 +1,11 @@
import { GraphQLResolveInfo, ExecutionResult, GraphQLFormattedError } from 'graphql';
export declare let ERROR_SYMBOL: any;
export declare function annotateWithChildrenErrors(object: any, childrenErrors: ReadonlyArray<GraphQLFormattedError>): any;
export declare function getErrorsFromParent(object: any, fieldName: string): {
kind: 'OWN';
error: any;
} | {
kind: 'CHILDREN';
errors?: Array<GraphQLFormattedError>;
};
export declare function checkResultAndHandleErrors(result: ExecutionResult, info: GraphQLResolveInfo, responseKey?: string): any;

114
node_modules/graphql-tools/dist/stitching/errors.js generated vendored Normal file
View File

@@ -0,0 +1,114 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
var error_1 = require("graphql/error");
var getResponseKeyFromInfo_1 = require("./getResponseKeyFromInfo");
if ((typeof global !== 'undefined' && 'Symbol' in global) ||
(typeof window !== 'undefined' && 'Symbol' in window)) {
exports.ERROR_SYMBOL = Symbol('subSchemaErrors');
}
else {
exports.ERROR_SYMBOL = '@@__subSchemaErrors';
}
function annotateWithChildrenErrors(object, childrenErrors) {
var _a;
if (!childrenErrors || childrenErrors.length === 0) {
// Nothing to see here, move along
return object;
}
if (Array.isArray(object)) {
var byIndex_1 = {};
childrenErrors.forEach(function (error) {
if (!error.path) {
return;
}
var index = error.path[1];
var current = byIndex_1[index] || [];
current.push(__assign(__assign({}, error), { path: error.path.slice(1) }));
byIndex_1[index] = current;
});
return object.map(function (item, index) { return annotateWithChildrenErrors(item, byIndex_1[index]); });
}
return __assign(__assign({}, object), (_a = {}, _a[exports.ERROR_SYMBOL] = childrenErrors.map(function (error) { return (__assign(__assign({}, error), (error.path ? { path: error.path.slice(1) } : {}))); }), _a));
}
exports.annotateWithChildrenErrors = annotateWithChildrenErrors;
function getErrorsFromParent(object, fieldName) {
var errors = (object && object[exports.ERROR_SYMBOL]) || [];
var childrenErrors = [];
for (var _i = 0, errors_1 = errors; _i < errors_1.length; _i++) {
var error = errors_1[_i];
if (!error.path || (error.path.length === 1 && error.path[0] === fieldName)) {
return {
kind: 'OWN',
error: error
};
}
else if (error.path[0] === fieldName) {
childrenErrors.push(error);
}
}
return {
kind: 'CHILDREN',
errors: childrenErrors
};
}
exports.getErrorsFromParent = getErrorsFromParent;
var CombinedError = /** @class */ (function (_super) {
__extends(CombinedError, _super);
function CombinedError(message, errors) {
var _this = _super.call(this, message) || this;
_this.errors = errors;
return _this;
}
return CombinedError;
}(Error));
function checkResultAndHandleErrors(result, info, responseKey) {
if (!responseKey) {
responseKey = getResponseKeyFromInfo_1.getResponseKeyFromInfo(info);
}
if (result.errors && (!result.data || result.data[responseKey] == null)) {
// apollo-link-http & http-link-dataloader need the
// result property to be passed through for better error handling.
// If there is only one error, which contains a result property, pass the error through
var newError = result.errors.length === 1 && hasResult(result.errors[0])
? result.errors[0]
: new CombinedError(concatErrors(result.errors), result.errors);
throw error_1.locatedError(newError, info.fieldNodes, graphql_1.responsePathAsArray(info.path));
}
var resultObject = result.data[responseKey];
if (result.errors) {
resultObject = annotateWithChildrenErrors(resultObject, result.errors);
}
return resultObject;
}
exports.checkResultAndHandleErrors = checkResultAndHandleErrors;
function concatErrors(errors) {
return errors.map(function (error) { return error.message; }).join('\n');
}
function hasResult(error) {
return error.result || error.extensions || (error.originalError && error.originalError.result);
}
//# sourceMappingURL=errors.js.map

1
node_modules/graphql-tools/dist/stitching/errors.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/stitching/errors.ts"],"names":[],"mappings":"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"}

7
node_modules/graphql-tools/dist/stitching/getResponseKeyFromInfo.d.ts generated vendored Normal file
View File

@@ -0,0 +1,7 @@
import { GraphQLResolveInfo } from 'graphql';
/**
* Get the key under which the result of this resolver will be placed in the response JSON. Basically, just
* resolves aliases.
* @param info The info argument to the resolver.
*/
export declare function getResponseKeyFromInfo(info: GraphQLResolveInfo): string;

11
node_modules/graphql-tools/dist/stitching/getResponseKeyFromInfo.js generated vendored Normal file
View File

@@ -0,0 +1,11 @@
Object.defineProperty(exports, "__esModule", { value: true });
/**
* Get the key under which the result of this resolver will be placed in the response JSON. Basically, just
* resolves aliases.
* @param info The info argument to the resolver.
*/
function getResponseKeyFromInfo(info) {
return info.fieldNodes[0].alias ? info.fieldNodes[0].alias.value : info.fieldName;
}
exports.getResponseKeyFromInfo = getResponseKeyFromInfo;
//# sourceMappingURL=getResponseKeyFromInfo.js.map

1
node_modules/graphql-tools/dist/stitching/getResponseKeyFromInfo.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"getResponseKeyFromInfo.js","sourceRoot":"","sources":["../../src/stitching/getResponseKeyFromInfo.ts"],"names":[],"mappings":";AAEA;;;;GAIG;AACH,SAAgB,sBAAsB,CAAC,IAAwB;IAC7D,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;AACpF,CAAC;AAFD,wDAEC"}

6
node_modules/graphql-tools/dist/stitching/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,6 @@
import makeRemoteExecutableSchema, { createResolver as defaultCreateRemoteResolver } from './makeRemoteExecutableSchema';
import introspectSchema from './introspectSchema';
import mergeSchemas from './mergeSchemas';
import delegateToSchema from './delegateToSchema';
import defaultMergedResolver from './defaultMergedResolver';
export { makeRemoteExecutableSchema, introspectSchema, mergeSchemas, delegateToSchema, defaultMergedResolver, defaultCreateRemoteResolver };

13
node_modules/graphql-tools/dist/stitching/index.js generated vendored Normal file
View File

@@ -0,0 +1,13 @@
Object.defineProperty(exports, "__esModule", { value: true });
var makeRemoteExecutableSchema_1 = require("./makeRemoteExecutableSchema");
exports.makeRemoteExecutableSchema = makeRemoteExecutableSchema_1.default;
exports.defaultCreateRemoteResolver = makeRemoteExecutableSchema_1.createResolver;
var introspectSchema_1 = require("./introspectSchema");
exports.introspectSchema = introspectSchema_1.default;
var mergeSchemas_1 = require("./mergeSchemas");
exports.mergeSchemas = mergeSchemas_1.default;
var delegateToSchema_1 = require("./delegateToSchema");
exports.delegateToSchema = delegateToSchema_1.default;
var defaultMergedResolver_1 = require("./defaultMergedResolver");
exports.defaultMergedResolver = defaultMergedResolver_1.default;
//# sourceMappingURL=index.js.map

1
node_modules/graphql-tools/dist/stitching/index.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/stitching/index.ts"],"names":[],"mappings":";AAAA,2EAAyH;AAOvH,qCAPK,oCAA0B,CAOL;AAO1B,sCAdqD,2CAA2B,CAcrD;AAb7B,uDAAkD;AAOhD,2BAPK,0BAAgB,CAOL;AANlB,+CAA0C;AAOxC,uBAPK,sBAAY,CAOL;AANd,uDAAkD;AAShD,2BATK,0BAAgB,CASL;AARlB,iEAA4D;AAS1D,gCATK,+BAAqB,CASL"}

6
node_modules/graphql-tools/dist/stitching/introspectSchema.d.ts generated vendored Normal file
View File

@@ -0,0 +1,6 @@
import { GraphQLSchema } from 'graphql';
import { ApolloLink } from 'apollo-link';
import { Fetcher } from './makeRemoteExecutableSchema';
export default function introspectSchema(fetcher: ApolloLink | Fetcher, linkContext?: {
[key: string]: any;
}): Promise<GraphQLSchema>;

72
node_modules/graphql-tools/dist/stitching/introspectSchema.js generated vendored Normal file
View File

@@ -0,0 +1,72 @@
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
var utilities_1 = require("graphql/utilities");
var linkToFetcher_1 = require("./linkToFetcher");
var parsedIntrospectionQuery = graphql_1.parse(utilities_1.getIntrospectionQuery());
function introspectSchema(fetcher, linkContext) {
return __awaiter(this, void 0, void 0, function () {
var introspectionResult, schema;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
// Convert link to fetcher
if (fetcher.request) {
fetcher = linkToFetcher_1.default(fetcher);
}
return [4 /*yield*/, fetcher({
query: parsedIntrospectionQuery,
context: linkContext,
})];
case 1:
introspectionResult = _a.sent();
if ((introspectionResult.errors && introspectionResult.errors.length) ||
!introspectionResult.data.__schema) {
throw introspectionResult.errors;
}
else {
schema = graphql_1.buildClientSchema(introspectionResult.data);
return [2 /*return*/, schema];
}
return [2 /*return*/];
}
});
});
}
exports.default = introspectSchema;
//# sourceMappingURL=introspectSchema.js.map

1
node_modules/graphql-tools/dist/stitching/introspectSchema.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"introspectSchema.js","sourceRoot":"","sources":["../../src/stitching/introspectSchema.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,mCAAmD;AACnD,+CAA0D;AAG1D,iDAA4C;AAE5C,IAAM,wBAAwB,GAAiB,eAAK,CAAC,iCAAqB,EAAE,CAAC,CAAC;AAE9E,SAA8B,gBAAgB,CAC5C,OAA6B,EAC7B,WAAoC;;;;;;oBAEpC,0BAA0B;oBAC1B,IAAK,OAAsB,CAAC,OAAO,EAAE;wBACnC,OAAO,GAAG,uBAAa,CAAC,OAAqB,CAAC,CAAC;qBAChD;oBAE2B,qBAAO,OAAmB,CAAC;4BACrD,KAAK,EAAE,wBAAwB;4BAC/B,OAAO,EAAE,WAAW;yBACrB,CAAC,EAAA;;oBAHI,mBAAmB,GAAG,SAG1B;oBAEF,IACE,CAAC,mBAAmB,CAAC,MAAM,IAAI,mBAAmB,CAAC,MAAM,CAAC,MAAM,CAAC;wBACjE,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,EAClC;wBACA,MAAM,mBAAmB,CAAC,MAAM,CAAC;qBAClC;yBAAM;wBACC,MAAM,GAAG,2BAAiB,CAAC,mBAAmB,CAAC,IAEpD,CAAC,CAAC;wBACH,sBAAO,MAAM,EAAC;qBACf;;;;;CACF;AAzBD,mCAyBC"}

Some files were not shown because too many files have changed in this diff Show More