commit 4ded93629e2ce082039f72bbb63e77a016e020b9 · kitten.sh/urql

.changeset/nervous-beds-battle.md

···

       1
       1
       +
       ---

     

       2
       2
       +
       '@urql/exchange-graphcache': patch

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Replace `graphql/utilities/buildClientSchema.mjs` with a custom-tailored, lighter implementation

     

       6
       6
       +
       built into `@urql/exchange-graphcache`. This will appear to increase its size by about `0.2kB gzip`

     

       7
       7
       +
       but will actually save around `8.5kB gzip` to `9.4kB gzip` in any production bundle by using less of

     

       8
       8
       +
       `graphql`'s code.

exchanges/graphcache/src/ast/index.ts

···

       1
       1
        
       export * from './variables';

     

       2
       2
        
       export * from './traversal';

     

       3
       3
       +
       export * from './schema';

     

       3
       4
        
       export * from './schemaPredicates';

     

       4
       5
        
       export * from './node';

+107

exchanges/graphcache/src/ast/schema.ts

···

       1
       1
       +
       import {

     

       2
       2
       +
         IntrospectionQuery,

     

       3
       3
       +
         IntrospectionInputValue,

     

       4
       4
       +
         IntrospectionTypeRef,

     

       5
       5
       +
         IntrospectionType,

     

       6
       6
       +
       } from 'graphql';

     

       7
       7
       +
       

     

       8
       8
       +
       export interface SchemaField {

     

       9
       9
       +
         name: string;

     

       10
       10
       +
         type: IntrospectionTypeRef;

     

       11
       11
       +
         args: Record<string, IntrospectionInputValue>;

     

       12
       12
       +
       }

     

       13
       13
       +
       

     

       14
       14
       +
       export interface SchemaObject {

     

       15
       15
       +
         name: string;

     

       16
       16
       +
         kind: 'INTERFACE' | 'OBJECT';

     

       17
       17
       +
         interfaces: Record<string, unknown>;

     

       18
       18
       +
         fields: Record<string, SchemaField>;

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       export interface SchemaUnion {

     

       22
       22
       +
         name: string;

     

       23
       23
       +
         kind: 'UNION';

     

       24
       24
       +
         types: Record<string, unknown>;

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       export interface SchemaIntrospector {

     

       28
       28
       +
         query: string | null;

     

       29
       29
       +
         mutation: string | null;

     

       30
       30
       +
         subscription: string | null;

     

       31
       31
       +
         types: Record<string, SchemaObject | SchemaUnion>;

     

       32
       32
       +
         isSubType(abstract: string, possible: string): boolean;

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

       35
       35
       +
       export const buildClientSchema = ({

     

       36
       36
       +
         __schema,

     

       37
       37
       +
       }: IntrospectionQuery): SchemaIntrospector => {

     

       38
       38
       +
         const typemap: Record<string, SchemaObject | SchemaUnion> = {};

     

       39
       39
       +
       

     

       40
       40
       +
         const buildNameMap = <T extends { name: string }>(

     

       41
       41
       +
           arr: ReadonlyArray<T>

     

       42
       42
       +
         ): { [name: string]: T } => {

     

       43
       43
       +
           const map: Record<string, T> = {};

     

       44
       44
       +
           for (let i = 0; i < arr.length; i++) map[arr[i].name] = arr[i];

     

       45
       45
       +
           return map;

     

       46
       46
       +
         };

     

       47
       47
       +
       

     

       48
       48
       +
         const buildType = (

     

       49
       49
       +
           type: IntrospectionType

     

       50
       50
       +
         ): SchemaObject | SchemaUnion | void => {

     

       51
       51
       +
           switch (type.kind) {

     

       52
       52
       +
             case 'OBJECT':

     

       53
       53
       +
             case 'INTERFACE':

     

       54
       54
       +
               return {

     

       55
       55
       +
                 name: type.name,

     

       56
       56
       +
                 kind: type.kind as 'OBJECT' | 'INTERFACE',

     

       57
       57
       +
                 interfaces: buildNameMap(type.interfaces || []),

     

       58
       58
       +
                 fields: buildNameMap(

     

       59
       59
       +
                   type.fields.map(field => ({

     

       60
       60
       +
                     name: field.name,

     

       61
       61
       +
                     type: field.type,

     

       62
       62
       +
                     args: buildNameMap(field.args),

     

       63
       63
       +
                   }))

     

       64
       64
       +
                 ),

     

       65
       65
       +
               } as SchemaObject;

     

       66
       66
       +
             case 'UNION':

     

       67
       67
       +
               return {

     

       68
       68
       +
                 name: type.name,

     

       69
       69
       +
                 kind: type.kind as 'UNION',

     

       70
       70
       +
                 types: buildNameMap(type.possibleTypes || []),

     

       71
       71
       +
               } as SchemaUnion;

     

       72
       72
       +
           }

     

       73
       73
       +
         };

     

       74
       74
       +
       

     

       75
       75
       +
         for (let i = 0; i < __schema.types.length; i++) {

     

       76
       76
       +
           const type = __schema.types[i];

     

       77
       77
       +
           if (type && type.name) {

     

       78
       78
       +
             const out = buildType(type);

     

       79
       79
       +
             if (out) typemap[type.name] = out;

     

       80
       80
       +
           }

     

       81
       81
       +
         }

     

       82
       82
       +
       

     

       83
       83
       +
         return {

     

       84
       84
       +
           query: __schema.queryType ? __schema.queryType.name : null,

     

       85
       85
       +
           mutation: __schema.mutationType ? __schema.mutationType.name : null,

     

       86
       86
       +
           subscription: __schema.subscriptionType

     

       87
       87
       +
             ? __schema.subscriptionType.name

     

       88
       88
       +
             : null,

     

       89
       89
       +
           types: typemap,

     

       90
       90
       +
           isSubType(abstract: string, possible: string) {

     

       91
       91
       +
             const abstractType = typemap[abstract];

     

       92
       92
       +
             const possibleType = typemap[possible];

     

       93
       93
       +
             if (!abstractType || !possibleType) {

     

       94
       94
       +
               return false;

     

       95
       95
       +
             } else if (abstractType.kind === 'UNION') {

     

       96
       96
       +
               return !!abstractType.types[possible];

     

       97
       97
       +
             } else if (

     

       98
       98
       +
               abstractType.kind !== 'OBJECT' &&

     

       99
       99
       +
               possibleType.kind === 'OBJECT'

     

       100
       100
       +
             ) {

     

       101
       101
       +
               return !!possibleType.interfaces[abstract];

     

       102
       102
       +
             } else {

     

       103
       103
       +
               return abstract === possible;

     

       104
       104
       +
             }

     

       105
       105
       +
           },

     

       106
       106
       +
         };

     

       107
       107
       +
       };

+2 -1

exchanges/graphcache/src/ast/schemaPredicates.test.ts

···

       1
       1
       -
       import { Kind, InlineFragmentNode, buildClientSchema } from 'graphql';

     

       1
       1
       +
       import { Kind, InlineFragmentNode } from 'graphql';

     

       2
       2
        
       import { mocked } from 'ts-jest/utils';

     

       3
       3
       +
       import { buildClientSchema } from './schema';

     

       3
       4
        
       import * as SchemaPredicates from './schemaPredicates';

     

       4
       5
        
       

     

       5
       6
        
       describe('SchemaPredicates', () => {

+76 -92

exchanges/graphcache/src/ast/schemaPredicates.ts

···

       1
       1
       -
       import {

     

       2
       2
       -
         isNullableType,

     

       3
       3
       -
         isListType,

     

       4
       4
       -
         isNonNullType,

     

       5
       5
       -
         InlineFragmentNode,

     

       6
       6
       -
         FragmentDefinitionNode,

     

       7
       7
       -
         GraphQLSchema,

     

       8
       8
       -
         GraphQLAbstractType,

     

       9
       9
       -
         GraphQLObjectType,

     

       10
       10
       -
         GraphQLInterfaceType,

     

       11
       11
       -
         GraphQLUnionType,

     

       12
       12
       -
       } from 'graphql';

     

       1
       1
       +
       import { InlineFragmentNode, FragmentDefinitionNode } from 'graphql';

     

       13
       2
        
       

     

       14
       3
        
       import { warn, invariant } from '../helpers/help';

     

       15
       4
        
       import { getTypeCondition } from './node';

     

       5
       5
       +
       import { SchemaIntrospector, SchemaObject } from './schema';

     

       6
       6
       +
       

     

       16
       7
        
       import {

     

       17
       8
        
         KeyingConfig,

     

       18
       9
        
         UpdateResolver,

     
···

       23
       14
        
       const BUILTIN_FIELD_RE = /^__/;

     

       24
       15
        
       

     

       25
       16
        
       export const isFieldNullable = (

     

       26
       26
       -
         schema: GraphQLSchema,

     

       17
       17
       +
         schema: SchemaIntrospector,

     

       27
       18
        
         typename: string,

     

       28
       19
        
         fieldName: string

     

       29
       20
        
       ): boolean => {

     

       30
       21
        
         if (BUILTIN_FIELD_RE.test(fieldName)) return true;

     

       31
       22
        
         const field = getField(schema, typename, fieldName);

     

       32
       32
       -
         return !!field && isNullableType(field.type);

     

       23
       23
       +
         return !!field && field.type.kind !== 'NON_NULL';

     

       33
       24
        
       };

     

       34
       25
        
       

     

       35
       26
        
       export const isListNullable = (

     

       36
       36
       -
         schema: GraphQLSchema,

     

       27
       27
       +
         schema: SchemaIntrospector,

     

       37
       28
        
         typename: string,

     

       38
       29
        
         fieldName: string

     

       39
       30
        
       ): boolean => {

     

       40
       31
        
         const field = getField(schema, typename, fieldName);

     

       41
       32
        
         if (!field) return false;

     

       42
       42
       -
         const ofType = isNonNullType(field.type) ? field.type.ofType : field.type;

     

       43
       43
       -
         return isListType(ofType) && isNullableType(ofType.ofType);

     

       33
       33
       +
         const ofType =

     

       34
       34
       +
           field.type.kind === 'NON_NULL' ? field.type.ofType : field.type;

     

       35
       35
       +
         return ofType.kind === 'LIST' && ofType.ofType.kind !== 'NON_NULL';

     

       44
       36
        
       };

     

       45
       37
        
       

     

       46
       38
        
       export const isFieldAvailableOnType = (

     

       47
       47
       -
         schema: GraphQLSchema,

     

       39
       39
       +
         schema: SchemaIntrospector,

     

       48
       40
        
         typename: string,

     

       49
       41
        
         fieldName: string

     

       50
       42
        
       ): boolean => {

     
···

       53
       45
        
       };

     

       54
       46
        
       

     

       55
       47
        
       export const isInterfaceOfType = (

     

       56
       56
       -
         schema: GraphQLSchema,

     

       48
       48
       +
         schema: SchemaIntrospector,

     

       57
       49
        
         node: InlineFragmentNode | FragmentDefinitionNode,

     

       58
       50
        
         typename: string | void

     

       59
       51
        
       ): boolean => {

     

       60
       52
        
         if (!typename) return false;

     

       61
       53
        
         const typeCondition = getTypeCondition(node);

     

       62
       54
        
         if (!typeCondition || typename === typeCondition) return true;

     

       63
       63
       -
       

     

       64
       64
       -
         const abstractType = schema.getType(typeCondition);

     

       65
       65
       -
         const objectType = schema.getType(typename);

     

       66
       66
       -
       

     

       67
       67
       -
         if (abstractType instanceof GraphQLObjectType) {

     

       68
       68
       -
           return abstractType === objectType;

     

       69
       69
       -
         }

     

       70
       70
       -
       

     

       71
       71
       -
         expectAbstractType(abstractType, typeCondition);

     

       72
       72
       -
         expectObjectType(objectType, typename);

     

       73
       73
       -
         return schema.isPossibleType(abstractType, objectType);

     

       55
       55
       +
         if (

     

       56
       56
       +
           schema.types[typeCondition] &&

     

       57
       57
       +
           schema.types[typeCondition].kind === 'OBJECT'

     

       58
       58
       +
         )

     

       59
       59
       +
           return typeCondition === typename;

     

       60
       60
       +
         expectAbstractType(schema, typeCondition!);

     

       61
       61
       +
         expectObjectType(schema, typename!);

     

       62
       62
       +
         return schema.isSubType(typeCondition, typename);

     

       74
       63
        
       };

     

       75
       64
        
       

     

       76
       65
        
       const getField = (

     

       77
       77
       -
         schema: GraphQLSchema,

     

       66
       66
       +
         schema: SchemaIntrospector,

     

       78
       67
        
         typename: string,

     

       79
       68
        
         fieldName: string

     

       80
       69
        
       ) => {

     

       81
       81
       -
         const object = schema.getType(typename);

     

       82
       82
       -
         expectObjectType(object, typename);

     

       83
       83
       -
       

     

       84
       84
       -
         const field = object.getFields()[fieldName];

     

       70
       70
       +
         expectObjectType(schema, typename);

     

       71
       71
       +
         const object = schema.types[typename] as SchemaObject;

     

       72
       72
       +
         const field = object.fields[fieldName];

     

       85
       73
        
         if (!field) {

     

       86
       74
        
           warn(

     

       87
       75
        
             'Invalid field: The field `' +

     
···

       98
       86
        
         return field;

     

       99
       87
        
       };

     

       100
       88
        
       

     

       101
       101
       -
       function expectObjectType(

     

       102
       102
       -
         x: any,

     

       103
       103
       -
         typename: string

     

       104
       104
       -
       ): asserts x is GraphQLObjectType {

     

       89
       89
       +
       function expectObjectType(schema: SchemaIntrospector, typename: string) {

     

       105
       90
        
         invariant(

     

       106
       106
       -
           x instanceof GraphQLObjectType,

     

       91
       91
       +
           schema.types[typename] && schema.types[typename].kind === 'OBJECT',

     

       107
       92
        
           'Invalid Object type: The type `' +

     

       108
       93
        
             typename +

     

       109
       94
        
             '` is not an object in the defined schema, ' +

     
···

       112
       97
        
         );

     

       113
       98
        
       }

     

       114
       99
        
       

     

       115
       115
       -
       function expectAbstractType(

     

       116
       116
       -
         x: any,

     

       117
       117
       -
         typename: string

     

       118
       118
       -
       ): asserts x is GraphQLAbstractType {

     

       100
       100
       +
       function expectAbstractType(schema: SchemaIntrospector, typename: string) {

     

       119
       101
        
         invariant(

     

       120
       120
       -
           x instanceof GraphQLInterfaceType || x instanceof GraphQLUnionType,

     

       102
       102
       +
           schema.types[typename] &&

     

       103
       103
       +
             (schema.types[typename].kind === 'INTERFACE' ||

     

       104
       104
       +
               schema.types[typename].kind === 'UNION'),

     

       121
       105
        
           'Invalid Abstract type: The type `' +

     

       122
       106
        
             typename +

     

       123
       107
        
             '` is not an Interface or Union type in the defined schema, ' +

     
···

       127
       111
        
       }

     

       128
       112
        
       

     

       129
       113
        
       export function expectValidKeyingConfig(

     

       130
       130
       -
         schema: GraphQLSchema,

     

       114
       114
       +
         schema: SchemaIntrospector,

     

       131
       115
        
         keys: KeyingConfig

     

       132
       116
        
       ): void {

     

       133
       117
        
         if (process.env.NODE_ENV !== 'production') {

     

       134
       134
       -
           const types = schema.getTypeMap();

     

       135
       118
        
           for (const key in keys) {

     

       136
       136
       -
             if (!types[key]) {

     

       119
       119
       +
             if (!schema.types[key]) {

     

       137
       120
        
               warn(

     

       138
       121
        
                 'Invalid Object type: The type `' +

     

       139
       122
        
                   key +

     
···

       146
       129
        
       }

     

       147
       130
        
       

     

       148
       131
        
       export function expectValidUpdatesConfig(

     

       149
       149
       -
         schema: GraphQLSchema,

     

       132
       132
       +
         schema: SchemaIntrospector,

     

       150
       133
        
         updates: Record<string, Record<string, UpdateResolver>>

     

       151
       134
        
       ): void {

     

       152
       135
        
         if (process.env.NODE_ENV === 'production') {

     

       153
       136
        
           return;

     

       154
       137
        
         }

     

       155
       138
        
       

     

       156
       156
       -
         const mutation = schema.getMutationType();

     

       157
       157
       -
         const subscription = schema.getSubscriptionType();

     

       158
       158
       -
         const mutationFields = mutation ? mutation.getFields() : {};

     

       159
       159
       -
         const subscriptionFields = subscription ? subscription.getFields() : {};

     

       160
       160
       -
         const givenMutations = (mutation && updates[mutation.name]) || {};

     

       161
       161
       -
         const givenSubscription = (subscription && updates[subscription.name]) || {};

     

       162
       162
       -
       

     

       163
       163
       -
         for (const fieldName in givenMutations) {

     

       164
       164
       -
           if (mutationFields[fieldName] === undefined) {

     

       165
       165
       -
             warn(

     

       166
       166
       -
               'Invalid mutation field: `' +

     

       167
       167
       -
                 fieldName +

     

       168
       168
       -
                 '` is not in the defined schema, but the `updates.Mutation` option is referencing it.',

     

       169
       169
       -
               21

     

       170
       170
       -
             );

     

       139
       139
       +
         if (schema.mutation) {

     

       140
       140
       +
           const mutationFields = (schema.types[schema.mutation] as SchemaObject)

     

       141
       141
       +
             .fields;

     

       142
       142
       +
           const givenMutations = updates[schema.mutation] || {};

     

       143
       143
       +
           for (const fieldName in givenMutations) {

     

       144
       144
       +
             if (mutationFields[fieldName] === undefined) {

     

       145
       145
       +
               warn(

     

       146
       146
       +
                 'Invalid mutation field: `' +

     

       147
       147
       +
                   fieldName +

     

       148
       148
       +
                   '` is not in the defined schema, but the `updates.Mutation` option is referencing it.',

     

       149
       149
       +
                 21

     

       150
       150
       +
               );

     

       151
       151
       +
             }

     

       171
       152
        
           }

     

       172
       153
        
         }

     

       173
       154
        
       

     

       174
       174
       -
         for (const fieldName in givenSubscription) {

     

       175
       175
       -
           if (subscriptionFields[fieldName] === undefined) {

     

       176
       176
       -
             warn(

     

       177
       177
       -
               'Invalid subscription field: `' +

     

       178
       178
       -
                 fieldName +

     

       179
       179
       -
                 '` is not in the defined schema, but the `updates.Subscription` option is referencing it.',

     

       180
       180
       -
               22

     

       181
       181
       -
             );

     

       155
       155
       +
         if (schema.subscription) {

     

       156
       156
       +
           const subscriptionFields = (schema.types[

     

       157
       157
       +
             schema.subscription

     

       158
       158
       +
           ] as SchemaObject).fields;

     

       159
       159
       +
           const givenSubscription = updates[schema.subscription] || {};

     

       160
       160
       +
           for (const fieldName in givenSubscription) {

     

       161
       161
       +
             if (subscriptionFields[fieldName] === undefined) {

     

       162
       162
       +
               warn(

     

       163
       163
       +
                 'Invalid subscription field: `' +

     

       164
       164
       +
                   fieldName +

     

       165
       165
       +
                   '` is not in the defined schema, but the `updates.Subscription` option is referencing it.',

     

       166
       166
       +
                 22

     

       167
       167
       +
               );

     

       168
       168
       +
             }

     

       182
       169
        
           }

     

       183
       170
        
         }

     

       184
       171
        
       }

     
···

       191
       178
        
       }

     

       192
       179
        
       

     

       193
       180
        
       export function expectValidResolversConfig(

     

       194
       194
       -
         schema: GraphQLSchema,

     

       181
       181
       +
         schema: SchemaIntrospector,

     

       195
       182
        
         resolvers: ResolverConfig

     

       196
       183
        
       ): void {

     

       197
       184
        
         if (process.env.NODE_ENV === 'production') {

     

       198
       185
        
           return;

     

       199
       186
        
         }

     

       200
       187
        
       

     

       201
       201
       -
         const validTypes = schema.getTypeMap();

     

       202
       188
        
         for (const key in resolvers) {

     

       203
       189
        
           if (key === 'Query') {

     

       204
       204
       -
             const queryType = schema.getQueryType();

     

       205
       205
       -
             if (queryType) {

     

       206
       206
       -
               const validQueries = queryType.getFields();

     

       190
       190
       +
             if (schema.query) {

     

       191
       191
       +
               const validQueries = (schema.types[schema.query] as SchemaObject)

     

       192
       192
       +
                 .fields;

     

       207
       193
        
               for (const resolverQuery in resolvers.Query) {

     

       208
       194
        
                 if (!validQueries[resolverQuery]) {

     

       209
       195
        
                   warnAboutResolver('Query.' + resolverQuery);

     
···

       213
       199
        
               warnAboutResolver('Query');

     

       214
       200
        
             }

     

       215
       201
        
           } else {

     

       216
       216
       -
             if (!validTypes[key]) {

     

       202
       202
       +
             if (!schema.types[key]) {

     

       217
       203
        
               warnAboutResolver(key);

     

       218
       204
        
             } else {

     

       219
       219
       -
               const validTypeProperties = (schema.getType(

     

       220
       220
       -
                 key

     

       221
       221
       -
               ) as GraphQLObjectType).getFields();

     

       205
       205
       +
               const validTypeProperties = (schema.types[key] as SchemaObject).fields;

     

       222
       206
        
               for (const resolverProperty in resolvers[key]) {

     

       223
       207
        
                 if (!validTypeProperties[resolverProperty]) {

     

       224
       208
        
                   warnAboutResolver(key + '.' + resolverProperty);

     
···

       230
       214
        
       }

     

       231
       215
        
       

     

       232
       216
        
       export function expectValidOptimisticMutationsConfig(

     

       233
       233
       -
         schema: GraphQLSchema,

     

       217
       217
       +
         schema: SchemaIntrospector,

     

       234
       218
        
         optimisticMutations: OptimisticMutationConfig

     

       235
       219
        
       ): void {

     

       236
       220
        
         if (process.env.NODE_ENV === 'production') {

     

       237
       221
        
           return;

     

       238
       222
        
         }

     

       239
       223
        
       

     

       240
       240
       -
         const validMutations = schema.getMutationType()

     

       241
       241
       -
           ? (schema.getMutationType() as GraphQLObjectType).getFields()

     

       242
       242
       -
           : {};

     

       243
       243
       -
       

     

       244
       244
       -
         for (const mutation in optimisticMutations) {

     

       245
       245
       -
           if (!validMutations[mutation]) {

     

       246
       246
       -
             warn(

     

       247
       247
       -
               `Invalid optimistic mutation field: \`${mutation}\` is not a mutation field in the defined schema, but the \`optimistic\` option is referencing it.`,

     

       248
       248
       -
               24

     

       249
       249
       -
             );

     

       224
       224
       +
         if (schema.mutation) {

     

       225
       225
       +
           const validMutations = (schema.types[schema.mutation] as SchemaObject)

     

       226
       226
       +
             .fields;

     

       227
       227
       +
           for (const mutation in optimisticMutations) {

     

       228
       228
       +
             if (!validMutations[mutation]) {

     

       229
       229
       +
               warn(

     

       230
       230
       +
                 `Invalid optimistic mutation field: \`${mutation}\` is not a mutation field in the defined schema, but the \`optimistic\` option is referencing it.`,

     

       231
       231
       +
                 24

     

       232
       232
       +
               );

     

       233
       233
       +
             }

     

       250
       234
        
           }

     

       251
       235
        
         }

     

       252
       236
        
       }

+18 -20

exchanges/graphcache/src/store/store.ts

···

       1
       1
       -
       import {

     

       2
       2
       -
         buildClientSchema,

     

       3
       3
       -
         DocumentNode,

     

       4
       4
       -
         IntrospectionQuery,

     

       5
       5
       -
         GraphQLSchema,

     

       6
       6
       -
       } from 'graphql';

     

       1
       1
       +
       import { DocumentNode, IntrospectionQuery } from 'graphql';

     

       7
       2
        
       

     

       8
       3
        
       import { TypedDocumentNode, formatDocument, createRequest } from '@urql/core';

     

       9
       4
        
       

     
···

       27
       22
        
       import { invalidateEntity } from '../operations/invalidate';

     

       28
       23
        
       import { keyOfField } from './keys';

     

       29
       24
        
       import * as InMemoryData from './data';

     

       30
       30
       -
       import * as SchemaPredicates from '../ast/schemaPredicates';

     

       25
       25
       +
       

     

       26
       26
       +
       import {

     

       27
       27
       +
         SchemaIntrospector,

     

       28
       28
       +
         buildClientSchema,

     

       29
       29
       +
         expectValidKeyingConfig,

     

       30
       30
       +
         expectValidUpdatesConfig,

     

       31
       31
       +
         expectValidResolversConfig,

     

       32
       32
       +
         expectValidOptimisticMutationsConfig,

     

       33
       33
       +
       } from '../ast';

     

       31
       34
        
       

     

       32
       35
        
       type RootField = 'query' | 'mutation' | 'subscription';

     

       33
       36
        
       

     
···

       46
       49
        
         updates: Record<string, Record<string, UpdateResolver>>;

     

       47
       50
        
         optimisticMutations: OptimisticMutationConfig;

     

       48
       51
        
         keys: KeyingConfig;

     

       49
       49
       -
         schema?: GraphQLSchema;

     

       52
       52
       +
         schema?: SchemaIntrospector;

     

       50
       53
        
       

     

       51
       54
        
         rootFields: { query: string; mutation: string; subscription: string };

     

       52
       55
        
         rootNames: { [name: string]: RootField };

     
···

       63
       66
        
           let subscriptionName = 'Subscription';

     

       64
       67
        
           if (opts.schema) {

     

       65
       68
        
             const schema = (this.schema = buildClientSchema(opts.schema));

     

       66
       66
       -
             const queryType = schema.getQueryType();

     

       67
       67
       -
             const mutationType = schema.getMutationType();

     

       68
       68
       -
             const subscriptionType = schema.getSubscriptionType();

     

       69
       69
       -
             queryName = queryType ? queryType.name : queryName;

     

       70
       70
       -
             mutationName = mutationType ? mutationType.name : mutationName;

     

       71
       71
       -
             subscriptionName = subscriptionType

     

       72
       72
       -
               ? subscriptionType.name

     

       73
       73
       -
               : subscriptionName;

     

       69
       69
       +
             queryName = schema.query || queryName;

     

       70
       70
       +
             mutationName = schema.mutation || mutationName;

     

       71
       71
       +
             subscriptionName = schema.subscription || subscriptionName;

     

       74
       72
        
           }

     

       75
       73
        
       

     

       76
       74
        
           this.updates = {

     
···

       93
       91
        
           this.data = InMemoryData.make(queryName);

     

       94
       92
        
       

     

       95
       93
        
           if (this.schema && process.env.NODE_ENV !== 'production') {

     

       96
       96
       -
             SchemaPredicates.expectValidKeyingConfig(this.schema, this.keys);

     

       97
       97
       -
             SchemaPredicates.expectValidUpdatesConfig(this.schema, this.updates);

     

       98
       98
       -
             SchemaPredicates.expectValidResolversConfig(this.schema, this.resolvers);

     

       99
       99
       -
             SchemaPredicates.expectValidOptimisticMutationsConfig(

     

       94
       94
       +
             expectValidKeyingConfig(this.schema, this.keys);

     

       95
       95
       +
             expectValidUpdatesConfig(this.schema, this.updates);

     

       96
       96
       +
             expectValidResolversConfig(this.schema, this.resolvers);

     

       97
       97
       +
             expectValidOptimisticMutationsConfig(

     

       100
       98
        
               this.schema,

     

       101
       99
        
               this.optimisticMutations

     

       102
       100
        
             );