Skip to content

Commit 8cc8721

Browse files
ardatanardatan
authoredAug 9, 2022
Fix Merge Schemas behavior and remove legacy signature in addResolversToSchema (#4463)
* Fix Merge Schemas behavior and remove legacy signature in addResolversToSchema * Go * More improvements * Go * Satisfy Bob * Try to fix website * Try sth
·
release-1670524223671cross-inspect@1.0.0
1 parent d8dc67a commit 8cc8721

20 files changed

+956
-837
lines changed
 

‎.changeset/fifty-experts-unite.md

+76
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,76 @@
1+
---
2+
'@graphql-tools/schema': major
3+
---
4+
5+
Thanks @mattkrick and @borisno2!
6+
7+
## Breaking changes
8+
9+
`addResolversToSchema`;
10+
11+
If you are using the legacy parameters like below, you should update them to the new usage. Other than that, there is no functional change;
12+
13+
```ts
14+
// From
15+
addResolversToSchema(schema, resolvers, resolverValidationOptions)
16+
17+
// To
18+
addResolversToSchema({
19+
schema,
20+
resolvers,
21+
resolverValidationOptions
22+
})
23+
```
24+
25+
`mergeSchemas`;
26+
27+
The provided `resolver` overrides the resolvers in the `schema` with the same name;
28+
29+
The `hello` resolver in the `schema` would be overridden by the `hello` resolver in the `resolvers`. Before it was opposite which is not expected.
30+
31+
```ts
32+
const schema = makeExecutableSchema({
33+
typeDefs: `
34+
type Query {
35+
hello: String
36+
}
37+
`,
38+
resolvers: {
39+
Query: {
40+
hello: () => 'Hello world!'
41+
}
42+
}
43+
})
44+
45+
mergeSchemas({
46+
schemas: [schema],
47+
resolvers: {
48+
Query: {
49+
hello: () => 'New hello world'
50+
}
51+
}
52+
})
53+
```
54+
55+
`makeExecutableSchema` no longer takes `parseOptions` and you can pass those options directly;
56+
57+
```ts
58+
makeExecutableSchema({
59+
typeDefs: ``,
60+
parseOptions: {
61+
assumeValid: true
62+
}
63+
})
64+
65+
// After
66+
makeExecutableSchema({
67+
typeDefs: ``,
68+
assumeValid: true
69+
})
70+
```
71+
72+
`makeExecutableSchema` no longer does pruning and it doesn't take `pruningOptions` anymore.
73+
You can use `pruneSchema` from `@graphql-tools/utils` if you need.
74+
75+
`extractExtensionsFromSchema` moved from `@graphql-tools/merge` to `@graphql-tools/schema`.
76+
And `travelSchemaPossibleExtensions` has been dropped in favor of `mapSchema`.

‎.changeset/tiny-zoos-dance.md

+1-1
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33
'@graphql-tools/wrap': major
44
---
55

6-
Breaking changes;
6+
## Breaking changes
77

88
**Schema generation optimization by removing `transfomedSchema` parameter**
99

‎packages/load/src/schema.ts

+41-49
Original file line numberDiff line numberDiff line change
@@ -1,19 +1,12 @@
11
import { loadTypedefs, LoadTypedefsOptions, UnnormalizedTypeDefPointer, loadTypedefsSync } from './load-typedefs.js';
2-
import {
3-
GraphQLSchema,
4-
BuildSchemaOptions,
5-
DocumentNode,
6-
Source as GraphQLSource,
7-
print,
8-
lexicographicSortSchema,
9-
} from 'graphql';
10-
import { OPERATION_KINDS } from './documents.js';
11-
import { mergeSchemas, MergeSchemasConfig } from '@graphql-tools/schema';
12-
import { Source } from '@graphql-tools/utils';
2+
import { GraphQLSchema, BuildSchemaOptions, Source as GraphQLSource, print, lexicographicSortSchema } from 'graphql';
3+
import { OPERATION_KINDS } from './documents';
4+
import { IExecutableSchemaDefinition, mergeSchemas, extractExtensionsFromSchema } from '@graphql-tools/schema';
5+
import { getResolversFromSchema, IResolvers, SchemaExtensions, Source, TypeSource } from '@graphql-tools/utils';
136

147
export type LoadSchemaOptions = BuildSchemaOptions &
158
LoadTypedefsOptions &
16-
Partial<MergeSchemasConfig> & {
9+
Partial<IExecutableSchemaDefinition> & {
1710
/**
1811
* Adds a list of Sources in to `extensions.sources`
1912
*
@@ -35,22 +28,7 @@ export async function loadSchema(
3528
...options,
3629
filterKinds: OPERATION_KINDS,
3730
});
38-
39-
const { schemas, typeDefs } = collectSchemasAndTypeDefs(sources);
40-
schemas.push(...(options.schemas ?? []));
41-
const mergeSchemasOptions: MergeSchemasConfig = {
42-
...options,
43-
schemas: schemas.concat(options.schemas ?? []),
44-
typeDefs,
45-
};
46-
47-
const schema = typeDefs?.length === 0 && schemas?.length === 1 ? schemas[0] : mergeSchemas(mergeSchemasOptions);
48-
49-
if (options?.includeSources) {
50-
includeSources(schema, sources);
51-
}
52-
53-
return options.sort ? lexicographicSortSchema(schema) : schema;
31+
return getSchemaFromSources(sources, options);
5432
}
5533

5634
/**
@@ -66,20 +44,7 @@ export function loadSchemaSync(
6644
filterKinds: OPERATION_KINDS,
6745
...options,
6846
});
69-
70-
const { schemas, typeDefs } = collectSchemasAndTypeDefs(sources);
71-
72-
const schema = mergeSchemas({
73-
schemas,
74-
typeDefs,
75-
...options,
76-
});
77-
78-
if (options?.includeSources) {
79-
includeSources(schema, sources);
80-
}
81-
82-
return options.sort ? lexicographicSortSchema(schema) : schema;
47+
return getSchemaFromSources(sources, options);
8348
}
8449

8550
function includeSources(schema: GraphQLSchema, sources: Source[]) {
@@ -98,20 +63,47 @@ function includeSources(schema: GraphQLSchema, sources: Source[]) {
9863
};
9964
}
10065

101-
function collectSchemasAndTypeDefs(sources: Source[]) {
102-
const schemas: GraphQLSchema[] = [];
103-
const typeDefs: DocumentNode[] = [];
66+
function getSchemaFromSources(sources: Source[], options: LoadSchemaOptions) {
67+
if (sources.length === 1 && sources[0].schema != null && options.typeDefs == null && options.resolvers == null) {
68+
return options.sort ? lexicographicSortSchema(sources[0].schema) : sources[0].schema;
69+
}
70+
const { typeDefs, resolvers, schemaExtensions } = collectSchemaParts(sources);
71+
72+
const schema = mergeSchemas({
73+
...options,
74+
typeDefs,
75+
resolvers,
76+
schemaExtensions,
77+
});
78+
79+
if (options?.includeSources) {
80+
includeSources(schema, sources);
81+
}
82+
83+
return options.sort ? lexicographicSortSchema(schema) : schema;
84+
}
85+
86+
function collectSchemaParts(sources: Source[]) {
87+
const typeDefs: TypeSource[] = [];
88+
const resolvers: IResolvers[] = [];
89+
const schemaExtensions: SchemaExtensions[] = [];
10490

10591
for (const source of sources) {
10692
if (source.schema) {
107-
schemas.push(source.schema);
108-
} else if (source.document) {
109-
typeDefs.push(source.document);
93+
typeDefs.push(source.schema);
94+
resolvers.push(getResolversFromSchema(source.schema));
95+
schemaExtensions.push(extractExtensionsFromSchema(source.schema));
96+
} else {
97+
const typeDef = source.document || source.rawSDL;
98+
if (typeDef) {
99+
typeDefs.push(typeDef);
100+
}
110101
}
111102
}
112103

113104
return {
114-
schemas,
115105
typeDefs,
106+
resolvers,
107+
schemaExtensions,
116108
};
117109
}

‎packages/merge/src/extensions.ts

+2-179
Original file line numberDiff line numberDiff line change
@@ -1,143 +1,5 @@
1-
import {
2-
GraphQLSchema,
3-
isObjectType,
4-
isInterfaceType,
5-
isInputObjectType,
6-
GraphQLField,
7-
GraphQLInputField,
8-
isUnionType,
9-
isScalarType,
10-
isEnumType,
11-
isSpecifiedScalarType,
12-
isIntrospectionType,
13-
GraphQLObjectType,
14-
GraphQLInputObjectType,
15-
GraphQLUnionType,
16-
GraphQLScalarType,
17-
GraphQLArgument,
18-
GraphQLEnumType,
19-
GraphQLEnumValue,
20-
GraphQLInterfaceType,
21-
} from 'graphql';
22-
import { Maybe, mergeDeep } from '@graphql-tools/utils';
23-
24-
export type ExtensionsObject = Record<string, any>;
25-
26-
export type ObjectTypeExtensions = {
27-
type: 'object';
28-
fields: Record<string, { extensions: ExtensionsObject; arguments: Record<string, ExtensionsObject> }>;
29-
};
30-
31-
export type InputTypeExtensions = {
32-
type: 'input';
33-
fields: Record<string, { extensions: ExtensionsObject }>;
34-
};
35-
36-
export type InterfaceTypeExtensions = {
37-
type: 'interface';
38-
fields: Record<string, { extensions: ExtensionsObject; arguments: Record<string, ExtensionsObject> }>;
39-
};
40-
41-
export type UnionTypeExtensions = {
42-
type: 'union';
43-
};
44-
45-
export type ScalarTypeExtensions = {
46-
type: 'scalar';
47-
};
48-
49-
export type EnumTypeExtensions = {
50-
type: 'enum';
51-
values: Record<string, ExtensionsObject>;
52-
};
53-
54-
export type PossibleTypeExtensions =
55-
| InputTypeExtensions
56-
| InterfaceTypeExtensions
57-
| ObjectTypeExtensions
58-
| UnionTypeExtensions
59-
| ScalarTypeExtensions
60-
| EnumTypeExtensions;
61-
export type SchemaExtensions = {
62-
schemaExtensions: ExtensionsObject;
63-
types: Record<string, { extensions: ExtensionsObject } & PossibleTypeExtensions>;
64-
};
65-
66-
export function travelSchemaPossibleExtensions(
67-
schema: GraphQLSchema,
68-
hooks: {
69-
onSchema: (schema: GraphQLSchema) => any;
70-
onObjectType: (type: GraphQLObjectType) => any;
71-
onObjectField: (type: GraphQLObjectType, field: GraphQLField<any, any>) => any;
72-
onObjectFieldArg: (type: GraphQLObjectType, field: GraphQLField<any, any>, arg: GraphQLArgument) => any;
73-
onInterface: (type: GraphQLInterfaceType) => any;
74-
onInterfaceField: (type: GraphQLInterfaceType, field: GraphQLField<any, any>) => any;
75-
onInterfaceFieldArg: (type: GraphQLInterfaceType, field: GraphQLField<any, any>, arg: GraphQLArgument) => any;
76-
onInputType: (type: GraphQLInputObjectType) => any;
77-
onInputFieldType: (type: GraphQLInputObjectType, field: GraphQLInputField) => any;
78-
onUnion: (type: GraphQLUnionType) => any;
79-
onScalar: (type: GraphQLScalarType) => any;
80-
onEnum: (type: GraphQLEnumType) => any;
81-
onEnumValue: (type: GraphQLEnumType, value: GraphQLEnumValue) => any;
82-
}
83-
) {
84-
hooks.onSchema(schema);
85-
const typesMap = schema.getTypeMap();
86-
87-
for (const [, type] of Object.entries(typesMap)) {
88-
const isPredefinedScalar = isScalarType(type) && isSpecifiedScalarType(type);
89-
const isIntrospection = isIntrospectionType(type);
90-
91-
if (isPredefinedScalar || isIntrospection) {
92-
continue;
93-
}
94-
95-
if (isObjectType(type)) {
96-
hooks.onObjectType(type);
97-
98-
const fields = type.getFields();
99-
for (const [, field] of Object.entries(fields)) {
100-
hooks.onObjectField(type, field);
101-
102-
const args = field.args || [];
103-
104-
for (const arg of args) {
105-
hooks.onObjectFieldArg(type, field, arg);
106-
}
107-
}
108-
} else if (isInterfaceType(type)) {
109-
hooks.onInterface(type);
110-
111-
const fields = type.getFields();
112-
for (const [, field] of Object.entries(fields)) {
113-
hooks.onInterfaceField(type, field);
114-
115-
const args = field.args || [];
116-
117-
for (const arg of args) {
118-
hooks.onInterfaceFieldArg(type, field, arg);
119-
}
120-
}
121-
} else if (isInputObjectType(type)) {
122-
hooks.onInputType(type);
123-
124-
const fields = type.getFields();
125-
for (const [, field] of Object.entries(fields)) {
126-
hooks.onInputFieldType(type, field);
127-
}
128-
} else if (isUnionType(type)) {
129-
hooks.onUnion(type);
130-
} else if (isScalarType(type)) {
131-
hooks.onScalar(type);
132-
} else if (isEnumType(type)) {
133-
hooks.onEnum(type);
134-
135-
for (const value of type.getValues()) {
136-
hooks.onEnumValue(type, value);
137-
}
138-
}
139-
}
140-
}
1+
import { GraphQLSchema, GraphQLObjectType, GraphQLEnumType } from 'graphql';
2+
import { ExtensionsObject, Maybe, mergeDeep, SchemaExtensions } from '@graphql-tools/utils';
1413

1424
export function mergeExtensions(extensions: SchemaExtensions[]): SchemaExtensions {
1435
return mergeDeep(extensions);
@@ -194,42 +56,3 @@ export function applyExtensions(schema: GraphQLSchema, extensions: SchemaExtensi
19456

19557
return schema;
19658
}
197-
198-
export function extractExtensionsFromSchema(schema: GraphQLSchema): SchemaExtensions {
199-
const result: SchemaExtensions = {
200-
schemaExtensions: {},
201-
types: {},
202-
};
203-
204-
travelSchemaPossibleExtensions(schema, {
205-
onSchema: schema => (result.schemaExtensions = schema.extensions || {}),
206-
onObjectType: type => (result.types[type.name] = { fields: {}, type: 'object', extensions: type.extensions || {} }),
207-
onObjectField: (type, field) =>
208-
((result.types[type.name] as ObjectTypeExtensions).fields[field.name] = {
209-
arguments: {},
210-
extensions: field.extensions || {},
211-
}),
212-
onObjectFieldArg: (type, field, arg) =>
213-
((result.types[type.name] as ObjectTypeExtensions).fields[field.name].arguments[arg.name] = arg.extensions || {}),
214-
onInterface: type =>
215-
(result.types[type.name] = { fields: {}, type: 'interface', extensions: type.extensions || {} }),
216-
onInterfaceField: (type, field) =>
217-
((result.types[type.name] as InterfaceTypeExtensions).fields[field.name] = {
218-
arguments: {},
219-
extensions: field.extensions || {},
220-
}),
221-
onInterfaceFieldArg: (type, field, arg) =>
222-
((result.types[type.name] as InterfaceTypeExtensions).fields[field.name].arguments[arg.name] =
223-
arg.extensions || {}),
224-
onEnum: type => (result.types[type.name] = { values: {}, type: 'enum', extensions: type.extensions || {} }),
225-
onEnumValue: (type, value) =>
226-
((result.types[type.name] as EnumTypeExtensions).values[value.name] = value.extensions || {}),
227-
onScalar: type => (result.types[type.name] = { type: 'scalar', extensions: type.extensions || {} }),
228-
onUnion: type => (result.types[type.name] = { type: 'union', extensions: type.extensions || {} }),
229-
onInputType: type => (result.types[type.name] = { fields: {}, type: 'input', extensions: type.extensions || {} }),
230-
onInputFieldType: (type, field) =>
231-
((result.types[type.name] as InputTypeExtensions).fields[field.name] = { extensions: field.extensions || {} }),
232-
});
233-
234-
return result;
235-
}

‎packages/merge/tests/extract-extensions-from-schema.spec.ts

+2-1
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,8 @@ import {
88
assertGraphQLScalerType,
99
} from '../../testing/assertion.js';
1010
import { assertSome } from '@graphql-tools/utils';
11-
import { extractExtensionsFromSchema, mergeExtensions, applyExtensions } from '../src/extensions.js';
11+
import { mergeExtensions, applyExtensions } from '../src/extensions.js';
12+
import { extractExtensionsFromSchema } from '@graphql-tools/schema';
1213

1314
describe('extensions', () => {
1415
let schema: GraphQLSchema;

‎packages/mock/src/addMocksToSchema.ts

+6-1
Original file line numberDiff line numberDiff line change
@@ -245,5 +245,10 @@ export function addMocksToSchema<TResolvers = IResolvers>({
245245
},
246246
});
247247

248-
return resolvers ? addResolversToSchema(schemaWithMocks, resolvers as any) : schemaWithMocks;
248+
return resolvers
249+
? addResolversToSchema({
250+
schema: schemaWithMocks,
251+
resolvers: resolvers as any,
252+
})
253+
: schemaWithMocks;
249254
}

‎packages/mock/tests/mocking-compatibility.spec.ts

+40-10
Original file line numberDiff line numberDiff line change
@@ -181,7 +181,10 @@ describe('Mock retro-compatibility', () => {
181181
returnString: () => 'someString',
182182
},
183183
};
184-
jsSchema = addResolversToSchema(jsSchema, resolvers);
184+
jsSchema = addResolversToSchema({
185+
schema: jsSchema,
186+
resolvers,
187+
});
185188
const testQuery = /* GraphQL */ `
186189
{
187190
returnInt
@@ -266,7 +269,10 @@ describe('Mock retro-compatibility', () => {
266269
},
267270
},
268271
};
269-
jsSchema = addResolversToSchema(jsSchema, resolvers);
272+
jsSchema = addResolversToSchema({
273+
schema: jsSchema,
274+
resolvers,
275+
});
270276
jsSchema = addMocksToSchema({
271277
schema: jsSchema,
272278
mocks: {},
@@ -625,7 +631,10 @@ describe('Mock retro-compatibility', () => {
625631
returnMockError: () => undefined,
626632
},
627633
};
628-
jsSchema = addResolversToSchema(jsSchema, resolvers);
634+
jsSchema = addResolversToSchema({
635+
schema: jsSchema,
636+
resolvers,
637+
});
629638

630639
const mockMap = {};
631640
jsSchema = addMocksToSchema({
@@ -656,7 +665,10 @@ describe('Mock retro-compatibility', () => {
656665
returnMockError: () => '10-11-2012',
657666
},
658667
};
659-
jsSchema = addResolversToSchema(jsSchema, resolvers);
668+
jsSchema = addResolversToSchema({
669+
schema: jsSchema,
670+
resolvers,
671+
});
660672

661673
const mockMap = {};
662674
addMocksToSchema({
@@ -875,7 +887,10 @@ describe('Mock retro-compatibility', () => {
875887
},
876888
},
877889
};
878-
jsSchema = addResolversToSchema(jsSchema, resolvers);
890+
jsSchema = addResolversToSchema({
891+
schema: jsSchema,
892+
resolvers,
893+
});
879894
const testQuery = /* GraphQL */ `
880895
{
881896
returnListOfListOfObject {
@@ -1064,7 +1079,10 @@ describe('Mock retro-compatibility', () => {
10641079
returnString: () => Promise.resolve('bar'), // see c)
10651080
},
10661081
};
1067-
jsSchema = addResolversToSchema(jsSchema, resolvers);
1082+
jsSchema = addResolversToSchema({
1083+
schema: jsSchema,
1084+
resolvers,
1085+
});
10681086
jsSchema = addMocksToSchema({
10691087
schema: jsSchema,
10701088
mocks: mockMap,
@@ -1129,7 +1147,10 @@ describe('Mock retro-compatibility', () => {
11291147
}),
11301148
},
11311149
};
1132-
jsSchema = addResolversToSchema(jsSchema, resolvers);
1150+
jsSchema = addResolversToSchema({
1151+
schema: jsSchema,
1152+
resolvers,
1153+
});
11331154
const mockMap = {
11341155
returnListOfInt: () => [5, 6, 7],
11351156
Bird: () => ({
@@ -1174,7 +1195,10 @@ describe('Mock retro-compatibility', () => {
11741195
}),
11751196
},
11761197
};
1177-
jsSchema = addResolversToSchema(jsSchema, resolvers);
1198+
jsSchema = addResolversToSchema({
1199+
schema: jsSchema,
1200+
resolvers,
1201+
});
11781202
const mockMap = {
11791203
Bird: () => ({
11801204
returnInt: 3, // see a)
@@ -1218,7 +1242,10 @@ describe('Mock retro-compatibility', () => {
12181242
returnObject: () => objProxy,
12191243
},
12201244
};
1221-
jsSchema = addResolversToSchema(jsSchema, resolvers);
1245+
jsSchema = addResolversToSchema({
1246+
schema: jsSchema,
1247+
resolvers,
1248+
});
12221249
const mockMap = {
12231250
Bird: () => ({
12241251
returnInt: 3, // see a)
@@ -1295,7 +1322,10 @@ describe('Mock retro-compatibility', () => {
12951322
returnString: () => null, // a) resolve of a string
12961323
},
12971324
};
1298-
jsSchema = addResolversToSchema(jsSchema, resolvers);
1325+
jsSchema = addResolversToSchema({
1326+
schema: jsSchema,
1327+
resolvers,
1328+
});
12991329
const mockMap = {
13001330
Int: () => 666, // b) mock of Int.
13011331
};

‎packages/schema/src/addResolversToSchema.ts

+8-24
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,6 @@
11
import {
22
GraphQLEnumType,
33
GraphQLSchema,
4-
isSchema,
54
GraphQLScalarType,
65
GraphQLUnionType,
76
GraphQLInterfaceType,
@@ -19,7 +18,6 @@ import {
1918

2019
import {
2120
IResolvers,
22-
IResolverValidationOptions,
2321
IAddResolversToSchemaOptions,
2422
mapSchema,
2523
MapperKind,
@@ -33,28 +31,14 @@ import {
3331
import { checkForResolveTypeResolver } from './checkForResolveTypeResolver.js';
3432
import { extendResolversFromInterfaces } from './extendResolversFromInterfaces.js';
3533

36-
export function addResolversToSchema(
37-
schemaOrOptions: GraphQLSchema | IAddResolversToSchemaOptions,
38-
legacyInputResolvers?: IResolvers,
39-
legacyInputValidationOptions?: IResolverValidationOptions
40-
): GraphQLSchema {
41-
const options: IAddResolversToSchemaOptions = isSchema(schemaOrOptions)
42-
? {
43-
schema: schemaOrOptions,
44-
resolvers: legacyInputResolvers ?? {},
45-
resolverValidationOptions: legacyInputValidationOptions,
46-
}
47-
: schemaOrOptions;
48-
49-
let {
50-
schema,
51-
resolvers: inputResolvers,
52-
defaultFieldResolver,
53-
resolverValidationOptions = {},
54-
inheritResolversFromInterfaces = false,
55-
updateResolversInPlace = false,
56-
} = options;
57-
34+
export function addResolversToSchema({
35+
schema,
36+
resolvers: inputResolvers,
37+
defaultFieldResolver,
38+
resolverValidationOptions = {},
39+
inheritResolversFromInterfaces = false,
40+
updateResolversInPlace = false,
41+
}: IAddResolversToSchemaOptions): GraphQLSchema {
5842
const { requireResolversToMatchSchema = 'error', requireResolversForResolveType } = resolverValidationOptions;
5943

6044
const resolvers = inheritResolversFromInterfaces

‎packages/schema/src/extractExtensionsFromSchema.ts

+69
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,69 @@
1+
import {
2+
SchemaExtensions,
3+
ObjectTypeExtensions,
4+
EnumTypeExtensions,
5+
InputTypeExtensions,
6+
mapSchema,
7+
MapperKind,
8+
} from '@graphql-tools/utils';
9+
import { GraphQLFieldConfig, GraphQLSchema } from 'graphql';
10+
11+
export function extractExtensionsFromSchema(schema: GraphQLSchema): SchemaExtensions {
12+
const result: SchemaExtensions = {
13+
schemaExtensions: schema.extensions || {},
14+
types: {},
15+
};
16+
17+
mapSchema(schema, {
18+
[MapperKind.OBJECT_TYPE]: type => {
19+
result.types[type.name] = { fields: {}, type: 'object', extensions: type.extensions || {} };
20+
return type;
21+
},
22+
[MapperKind.INTERFACE_TYPE]: type => {
23+
result.types[type.name] = { fields: {}, type: 'interface', extensions: type.extensions || {} };
24+
return type;
25+
},
26+
[MapperKind.FIELD]: (field, fieldName, typeName) => {
27+
(result.types[typeName] as ObjectTypeExtensions).fields[fieldName] = {
28+
arguments: {},
29+
extensions: field.extensions || {},
30+
};
31+
const args = (field as GraphQLFieldConfig<any, any>).args;
32+
if (args != null) {
33+
for (const argName in args) {
34+
(result.types[typeName] as ObjectTypeExtensions).fields[fieldName].arguments[argName] =
35+
args[argName].extensions || {};
36+
}
37+
}
38+
return field;
39+
},
40+
[MapperKind.ENUM_TYPE]: type => {
41+
result.types[type.name] = { values: {}, type: 'enum', extensions: type.extensions || {} };
42+
return type;
43+
},
44+
[MapperKind.ENUM_VALUE]: (value, typeName, _schema, valueName) => {
45+
(result.types[typeName] as EnumTypeExtensions).values[valueName] = value.extensions || {};
46+
return value;
47+
},
48+
[MapperKind.SCALAR_TYPE]: type => {
49+
result.types[type.name] = { type: 'scalar', extensions: type.extensions || {} };
50+
return type;
51+
},
52+
[MapperKind.UNION_TYPE]: type => {
53+
result.types[type.name] = { type: 'union', extensions: type.extensions || {} };
54+
return type;
55+
},
56+
[MapperKind.INPUT_OBJECT_TYPE]: type => {
57+
result.types[type.name] = { fields: {}, type: 'input', extensions: type.extensions || {} };
58+
return type;
59+
},
60+
[MapperKind.INPUT_OBJECT_FIELD]: (field, fieldName, typeName) => {
61+
(result.types[typeName] as InputTypeExtensions).fields[fieldName] = {
62+
extensions: field.extensions || {},
63+
};
64+
return field;
65+
},
66+
});
67+
68+
return result;
69+
}

‎packages/schema/src/index.ts

+1
Original file line numberDiff line numberDiff line change
@@ -6,3 +6,4 @@ export { extendResolversFromInterfaces } from './extendResolversFromInterfaces.j
66
export * from './makeExecutableSchema.js';
77
export * from './types.js';
88
export * from './merge-schemas.js';
9+
export * from './extractExtensionsFromSchema.js';

‎packages/schema/src/makeExecutableSchema.ts

+10-16
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
import { buildASTSchema, buildSchema, GraphQLSchema, isSchema } from 'graphql';
22

3-
import { asArray, pruneSchema } from '@graphql-tools/utils';
3+
import { asArray } from '@graphql-tools/utils';
44
import { addResolversToSchema } from './addResolversToSchema.js';
55

66
import { assertResolversPresent } from './assertResolversPresent.js';
@@ -15,12 +15,11 @@ import { applyExtensions, mergeExtensions, mergeResolvers, mergeTypeDefs } from
1515
* of these. If a function is provided, it will be passed no arguments and
1616
* should return an array of strings or `DocumentNode`s.
1717
*
18-
* Note: You can use `graphql-tag` to not only parse a string into a
19-
* `DocumentNode` but also to provide additional syntax highlighting in your
20-
* editor (with the appropriate editor plugin).
18+
* Note: You can use GraphQL magic comment provide additional syntax
19+
* highlighting in your editor (with the appropriate editor plugin).
2120
*
2221
* ```js
23-
* const typeDefs = gql`
22+
* const typeDefs = /* GraphQL *\/ `
2423
* type Query {
2524
* posts: [Post]
2625
* author(id: Int!): Author
@@ -55,11 +54,10 @@ export function makeExecutableSchema<TContext = any>({
5554
typeDefs,
5655
resolvers = {},
5756
resolverValidationOptions = {},
58-
parseOptions = {},
5957
inheritResolversFromInterfaces = false,
60-
pruningOptions,
6158
updateResolversInPlace = false,
6259
schemaExtensions,
60+
...otherOptions
6361
}: IExecutableSchemaDefinition<TContext>) {
6462
// Validate and clean up arguments
6563
if (typeof resolverValidationOptions !== 'object') {
@@ -74,19 +72,15 @@ export function makeExecutableSchema<TContext = any>({
7472

7573
if (isSchema(typeDefs)) {
7674
schema = typeDefs;
77-
} else if (parseOptions?.commentDescriptions) {
75+
} else if (otherOptions?.commentDescriptions) {
7876
const mergedTypeDefs = mergeTypeDefs(typeDefs, {
79-
...parseOptions,
77+
...otherOptions,
8078
commentDescriptions: true,
8179
});
82-
schema = buildSchema(mergedTypeDefs, parseOptions);
80+
schema = buildSchema(mergedTypeDefs, otherOptions);
8381
} else {
84-
const mergedTypeDefs = mergeTypeDefs(typeDefs, parseOptions);
85-
schema = buildASTSchema(mergedTypeDefs, parseOptions);
86-
}
87-
88-
if (pruningOptions) {
89-
schema = pruneSchema(schema);
82+
const mergedTypeDefs = mergeTypeDefs(typeDefs, otherOptions);
83+
schema = buildASTSchema(mergedTypeDefs, otherOptions);
9084
}
9185

9286
// We allow passing in an array of resolver maps, in which case we merge them

‎packages/schema/src/merge-schemas.ts

+31-18
Original file line numberDiff line numberDiff line change
@@ -1,38 +1,51 @@
11
import { GraphQLSchema } from 'graphql';
2-
import { extractExtensionsFromSchema, SchemaExtensions } from '@graphql-tools/merge';
3-
import { IResolvers, asArray, getResolversFromSchema, TypeSource } from '@graphql-tools/utils';
2+
import { IResolvers, asArray, getResolversFromSchema, TypeSource, SchemaExtensions } from '@graphql-tools/utils';
43
import { makeExecutableSchema } from './makeExecutableSchema.js';
54
import { IExecutableSchemaDefinition } from './types.js';
5+
import { extractExtensionsFromSchema } from './extractExtensionsFromSchema.js';
66

77
/**
88
* Configuration object for schema merging
99
*/
10-
export type MergeSchemasConfig<T = any> = Partial<IExecutableSchemaDefinition<T>> &
11-
IExecutableSchemaDefinition<T>['parseOptions'] & {
12-
/**
13-
* The schemas to be merged
14-
*/
15-
schemas?: GraphQLSchema[];
16-
};
10+
export type MergeSchemasConfig<T = any> = Partial<IExecutableSchemaDefinition<T>> & {
11+
/**
12+
* The schemas to be merged
13+
*/
14+
schemas?: GraphQLSchema[];
15+
};
1716

1817
/**
1918
* Synchronously merges multiple schemas, typeDefinitions and/or resolvers into a single schema.
2019
* @param config Configuration object
2120
*/
2221
export function mergeSchemas(config: MergeSchemasConfig) {
23-
const extractedTypeDefs: TypeSource = asArray(config.typeDefs || []);
24-
const extractedResolvers: IResolvers<any, any>[] = asArray(config.resolvers || []);
25-
const extractedSchemaExtensions: SchemaExtensions[] = asArray(config.schemaExtensions || []);
22+
const extractedTypeDefs: TypeSource[] = [];
23+
const extractedResolvers: IResolvers<any, any>[] = [];
24+
const extractedSchemaExtensions: SchemaExtensions[] = [];
2625

27-
const schemas = config.schemas || [];
28-
for (const schema of schemas) {
29-
extractedTypeDefs.push(schema);
30-
extractedResolvers.push(getResolversFromSchema(schema, true));
31-
extractedSchemaExtensions.push(extractExtensionsFromSchema(schema));
26+
if (config.schemas != null) {
27+
for (const schema of config.schemas) {
28+
extractedTypeDefs.push(schema);
29+
extractedResolvers.push(getResolversFromSchema(schema));
30+
extractedSchemaExtensions.push(extractExtensionsFromSchema(schema));
31+
}
32+
}
33+
34+
if (config.typeDefs != null) {
35+
extractedTypeDefs.push(config.typeDefs);
36+
}
37+
38+
if (config.resolvers != null) {
39+
const additionalResolvers = asArray(config.resolvers);
40+
extractedResolvers.push(...additionalResolvers);
41+
}
42+
43+
if (config.schemaExtensions != null) {
44+
const additionalSchemaExtensions = asArray(config.schemaExtensions);
45+
extractedSchemaExtensions.push(...additionalSchemaExtensions);
3246
}
3347

3448
return makeExecutableSchema({
35-
parseOptions: config,
3649
...config,
3750
typeDefs: extractedTypeDefs,
3851
resolvers: extractedResolvers,

‎packages/schema/src/types.ts

+7-13
Original file line numberDiff line numberDiff line change
@@ -3,15 +3,18 @@ import {
33
IResolvers,
44
IResolverValidationOptions,
55
GraphQLParseOptions,
6-
PruneSchemaOptions,
6+
SchemaExtensions,
77
} from '@graphql-tools/utils';
8-
import { SchemaExtensions } from '@graphql-tools/merge';
9-
import { BuildSchemaOptions } from 'graphql';
8+
import { BuildSchemaOptions, GraphQLSchema } from 'graphql';
9+
10+
export interface GraphQLSchemaWithContext<TContext> extends GraphQLSchema {
11+
__context?: TContext;
12+
}
1013

1114
/**
1215
* Configuration object for creating an executable schema
1316
*/
14-
export interface IExecutableSchemaDefinition<TContext = any> {
17+
export interface IExecutableSchemaDefinition<TContext = any> extends BuildSchemaOptions, GraphQLParseOptions {
1518
/**
1619
* The type definitions used to create the schema
1720
*/
@@ -24,20 +27,11 @@ export interface IExecutableSchemaDefinition<TContext = any> {
2427
* Additional options for validating the provided resolvers
2528
*/
2629
resolverValidationOptions?: IResolverValidationOptions;
27-
/**
28-
* Additional options for parsing the type definitions if they are provided
29-
* as a string
30-
*/
31-
parseOptions?: BuildSchemaOptions & GraphQLParseOptions;
3230
/**
3331
* GraphQL object types that implement interfaces will inherit any missing
3432
* resolvers from their interface types defined in the `resolvers` object
3533
*/
3634
inheritResolversFromInterfaces?: boolean;
37-
/**
38-
* Additional options for removing unused types from the schema
39-
*/
40-
pruningOptions?: PruneSchemaOptions;
4135
/**
4236
* Do not create a schema again and use the one from `buildASTSchema`
4337
*/

‎packages/schema/tests/merge-schemas.spec.ts

+55
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,61 @@ describe('Merge Schemas', () => {
4040
expect(mergedSchema.extensions).toEqual({ schemaA: true, schemaB: true });
4141
});
4242

43+
it('should override resolver in schema with resolver passed into config', async () => {
44+
const fooSchema = makeExecutableSchema({
45+
typeDefs: /* GraphQL */ `
46+
type Query {
47+
foo: String
48+
}
49+
`,
50+
resolvers: {
51+
Query: {
52+
foo: () => 'FOO',
53+
},
54+
},
55+
});
56+
const barSchema = makeExecutableSchema({
57+
typeDefs: /* GraphQL */ `
58+
type Query {
59+
bar: String
60+
}
61+
`,
62+
resolvers: {
63+
Query: {
64+
bar: () => 'BAR',
65+
},
66+
},
67+
});
68+
const { errors, data } = await graphql({
69+
schema: mergeSchemas({
70+
schemas: [fooSchema, barSchema],
71+
typeDefs: /* GraphQL */ `
72+
type Query {
73+
qux: String
74+
}
75+
`,
76+
resolvers: {
77+
Query: {
78+
qux: () => 'QUX',
79+
foo: () => 'FOO_BAR_QUX',
80+
},
81+
},
82+
}),
83+
source: `
84+
{
85+
foo
86+
bar
87+
qux
88+
}
89+
`,
90+
});
91+
expect(errors).toBeFalsy();
92+
assertSome(data);
93+
expect(data['foo']).toBe('FOO_BAR_QUX');
94+
expect(data['bar']).toBe('BAR');
95+
expect(data['qux']).toBe('QUX');
96+
});
97+
4398
it('should merge two valid executable schemas', async () => {
4499
const fooSchema = makeExecutableSchema({
45100
typeDefs: /* GraphQL */ `

‎packages/schema/tests/schemaGenerator.test.ts

+3-7
Original file line numberDiff line numberDiff line change
@@ -1961,9 +1961,7 @@ describe('can specify lexical parser options', () => {
19611961
}
19621962
`,
19631963
resolvers: {},
1964-
parseOptions: {
1965-
noLocation: true,
1966-
},
1964+
noLocation: true,
19671965
});
19681966

19691967
expect(schema.astNode!.loc).toBeUndefined();
@@ -1986,9 +1984,7 @@ describe('can specify lexical parser options', () => {
19861984
makeExecutableSchema({
19871985
typeDefs,
19881986
resolvers,
1989-
parseOptions: {
1990-
experimentalFragmentVariables: true,
1991-
},
1987+
experimentalFragmentVariables: true,
19921988
});
19931989
}).not.toThrowError();
19941990
});
@@ -2264,7 +2260,7 @@ describe('interface resolver inheritance', () => {
22642260
},
22652261
};
22662262
const schema = makeExecutableSchema({
2267-
parseOptions: { allowLegacySDLImplementsInterfaces: true },
2263+
allowLegacySDLImplementsInterfaces: true,
22682264
typeDefs: testSchemaWithInterfaceResolvers,
22692265
resolvers,
22702266
inheritResolversFromInterfaces: true,

‎packages/stitch/src/stitchSchemas.ts

+3-3
Original file line numberDiff line numberDiff line change
@@ -28,9 +28,9 @@ export function stitchSchemas<TContext extends Record<string, any> = Record<stri
2828
resolvers = {},
2929
inheritResolversFromInterfaces = false,
3030
resolverValidationOptions = {},
31-
parseOptions = {},
3231
updateResolversInPlace = true,
3332
schemaExtensions,
33+
...rest
3434
}: IStitchSchemasOptions<TContext>): GraphQLSchema {
3535
const transformedSubschemas: Array<Subschema<any, any, any, TContext>> = [];
3636
const subschemaMap: Map<
@@ -63,8 +63,8 @@ export function stitchSchemas<TContext extends Record<string, any> = Record<stri
6363
subschemas: transformedSubschemas,
6464
originalSubschemaMap,
6565
types,
66-
typeDefs,
67-
parseOptions,
66+
typeDefs: typeDefs || [],
67+
parseOptions: rest,
6868
directiveMap,
6969
schemaDefs,
7070
mergeDirectives,

‎packages/stitch/src/types.ts

-1
Original file line numberDiff line numberDiff line change
@@ -105,7 +105,6 @@ export type OnTypeConflict<TContext = Record<string, any>> = (
105105

106106
declare module '@graphql-tools/utils' {
107107
interface IFieldResolverOptions<TSource = any, TContext = any, TArgs = any> {
108-
fragment?: string;
109108
selectionSet?: string | ((node: FieldNode) => SelectionSetNode);
110109
}
111110
}

‎packages/utils/src/types.ts

+43
Original file line numberDiff line numberDiff line change
@@ -88,3 +88,46 @@ export enum DirectiveLocation {
8888
INPUT_OBJECT = 'INPUT_OBJECT',
8989
INPUT_FIELD_DEFINITION = 'INPUT_FIELD_DEFINITION',
9090
}
91+
92+
export type ExtensionsObject = Record<string, any>;
93+
94+
export type ObjectTypeExtensions = {
95+
type: 'object';
96+
fields: Record<string, { extensions: ExtensionsObject; arguments: Record<string, ExtensionsObject> }>;
97+
};
98+
99+
export type InputTypeExtensions = {
100+
type: 'input';
101+
fields: Record<string, { extensions: ExtensionsObject }>;
102+
};
103+
104+
export type InterfaceTypeExtensions = {
105+
type: 'interface';
106+
fields: Record<string, { extensions: ExtensionsObject; arguments: Record<string, ExtensionsObject> }>;
107+
};
108+
109+
export type UnionTypeExtensions = {
110+
type: 'union';
111+
};
112+
113+
export type ScalarTypeExtensions = {
114+
type: 'scalar';
115+
};
116+
117+
export type EnumTypeExtensions = {
118+
type: 'enum';
119+
values: Record<string, ExtensionsObject>;
120+
};
121+
122+
export type PossibleTypeExtensions =
123+
| InputTypeExtensions
124+
| InterfaceTypeExtensions
125+
| ObjectTypeExtensions
126+
| UnionTypeExtensions
127+
| ScalarTypeExtensions
128+
| EnumTypeExtensions;
129+
130+
export type SchemaExtensions = {
131+
schemaExtensions: ExtensionsObject;
132+
types: Record<string, { extensions: ExtensionsObject } & PossibleTypeExtensions>;
133+
};

‎website/package.json

+9-9
Original file line numberDiff line numberDiff line change
@@ -37,15 +37,15 @@
3737
"wait-on": "6.0.1"
3838
},
3939
"dependencies": {
40-
"@chakra-ui/icons": "2.0.6",
41-
"@chakra-ui/react": "2.2.6",
42-
"@chakra-ui/theme-tools": "2.0.7",
43-
"@chakra-ui/utils": "2.0.6",
44-
"@emotion/react": "11.10.0",
45-
"@emotion/styled": "11.10.0",
46-
"@guild-docs/client": "3.1.0",
47-
"@guild-docs/server": "4.0.0",
48-
"@mdx-js/react": "2.1.2",
40+
"@chakra-ui/icons": "^1.1.5",
41+
"@chakra-ui/react": "^1.8.3",
42+
"@chakra-ui/theme-tools": "^1.3.4",
43+
"@chakra-ui/utils": "^1.10.2",
44+
"@emotion/react": "^11.7.1",
45+
"@emotion/styled": "^11.6.0",
46+
"@guild-docs/client": "^3.0.2",
47+
"@guild-docs/server": "^4.0.0",
48+
"@mdx-js/react": "^2.1.1",
4949
"@theguild/components": "1.12.0",
5050
"framer-motion": "6.5.1",
5151
"next": "12.2.4",

‎yarn.lock

+549-505
Large diffs are not rendered by default.

0 commit comments

Comments
 (0)
Please sign in to comment.