commit 4ded93629e2ce082039f72bbb63e77a016e020b9 · kitten.sh/urql

.changeset/nervous-beds-battle.md

···

       1
       +
       ---

     

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

     

       3
       +
       ---

     

       4
       +
       

     

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

     

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

     

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

     

       8
       +
       `graphql`'s code.

exchanges/graphcache/src/ast/index.ts

···

       1
        
       export * from './variables';

     

       2
        
       export * from './traversal';

     

       0
        
       
     

       3
        
       export * from './schemaPredicates';

     

       4
        
       export * from './node';

···

       1
        
       export * from './variables';

     

       2
        
       export * from './traversal';

     

       3
       +
       export * from './schema';

     

       4
        
       export * from './schemaPredicates';

     

       5
        
       export * from './node';

+107

exchanges/graphcache/src/ast/schema.ts

···

       1
       +
       import {

     

       2
       +
         IntrospectionQuery,

     

       3
       +
         IntrospectionInputValue,

     

       4
       +
         IntrospectionTypeRef,

     

       5
       +
         IntrospectionType,

     

       6
       +
       } from 'graphql';

     

       7
       +
       

     

       8
       +
       export interface SchemaField {

     

       9
       +
         name: string;

     

       10
       +
         type: IntrospectionTypeRef;

     

       11
       +
         args: Record<string, IntrospectionInputValue>;

     

       12
       +
       }

     

       13
       +
       

     

       14
       +
       export interface SchemaObject {

     

       15
       +
         name: string;

     

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

     

       17
       +
         interfaces: Record<string, unknown>;

     

       18
       +
         fields: Record<string, SchemaField>;

     

       19
       +
       }

     

       20
       +
       

     

       21
       +
       export interface SchemaUnion {

     

       22
       +
         name: string;

     

       23
       +
         kind: 'UNION';

     

       24
       +
         types: Record<string, unknown>;

     

       25
       +
       }

     

       26
       +
       

     

       27
       +
       export interface SchemaIntrospector {

     

       28
       +
         query: string | null;

     

       29
       +
         mutation: string | null;

     

       30
       +
         subscription: string | null;

     

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

     

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

     

       33
       +
       }

     

       34
       +
       

     

       35
       +
       export const buildClientSchema = ({

     

       36
       +
         __schema,

     

       37
       +
       }: IntrospectionQuery): SchemaIntrospector => {

     

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

     

       39
       +
       

     

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

     

       41
       +
           arr: ReadonlyArray<T>

     

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

     

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

     

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

     

       45
       +
           return map;

     

       46
       +
         };

     

       47
       +
       

     

       48
       +
         const buildType = (

     

       49
       +
           type: IntrospectionType

     

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

     

       51
       +
           switch (type.kind) {

     

       52
       +
             case 'OBJECT':

     

       53
       +
             case 'INTERFACE':

     

       54
       +
               return {

     

       55
       +
                 name: type.name,

     

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

     

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

     

       58
       +
                 fields: buildNameMap(

     

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

     

       60
       +
                     name: field.name,

     

       61
       +
                     type: field.type,

     

       62
       +
                     args: buildNameMap(field.args),

     

       63
       +
                   }))

     

       64
       +
                 ),

     

       65
       +
               } as SchemaObject;

     

       66
       +
             case 'UNION':

     

       67
       +
               return {

     

       68
       +
                 name: type.name,

     

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

     

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

     

       71
       +
               } as SchemaUnion;

     

       72
       +
           }

     

       73
       +
         };

     

       74
       +
       

     

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

     

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

     

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

     

       78
       +
             const out = buildType(type);

     

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

     

       80
       +
           }

     

       81
       +
         }

     

       82
       +
       

     

       83
       +
         return {

     

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

     

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

     

       86
       +
           subscription: __schema.subscriptionType

     

       87
       +
             ? __schema.subscriptionType.name

     

       88
       +
             : null,

     

       89
       +
           types: typemap,

     

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

     

       91
       +
             const abstractType = typemap[abstract];

     

       92
       +
             const possibleType = typemap[possible];

     

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

     

       94
       +
               return false;

     

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

     

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

     

       97
       +
             } else if (

     

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

     

       99
       +
               possibleType.kind === 'OBJECT'

     

       100
       +
             ) {

     

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

     

       102
       +
             } else {

     

       103
       +
               return abstract === possible;

     

       104
       +
             }

     

       105
       +
           },

     

       106
       +
         };

     

       107
       +
       };

+2 -1

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

···

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

     

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

     

       0
        
       
     

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

     

       4
        
       

     

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

···

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

     

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

     

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

     

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

     

       5
        
       

     

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

+76 -92

exchanges/graphcache/src/ast/schemaPredicates.ts

···

       1
       -
       import {

     

       2
       -
         isNullableType,

     

       3
       -
         isListType,

     

       4
       -
         isNonNullType,

     

       5
       -
         InlineFragmentNode,

     

       6
       -
         FragmentDefinitionNode,

     

       7
       -
         GraphQLSchema,

     

       8
       -
         GraphQLAbstractType,

     

       9
       -
         GraphQLObjectType,

     

       10
       -
         GraphQLInterfaceType,

     

       11
       -
         GraphQLUnionType,

     

       12
       -
       } from 'graphql';

     

       13
        
       

     

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

     

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

     

       0
        
       
     

       0
        
       
     

       16
        
       import {

     

       17
        
         KeyingConfig,

     

       18
        
         UpdateResolver,

     
···

       23
        
       const BUILTIN_FIELD_RE = /^__/;

     

       24
        
       

     

       25
        
       export const isFieldNullable = (

     

       26
       -
         schema: GraphQLSchema,

     

       27
        
         typename: string,

     

       28
        
         fieldName: string

     

       29
        
       ): boolean => {

     

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

     

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

     

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

     

       33
        
       };

     

       34
        
       

     

       35
        
       export const isListNullable = (

     

       36
       -
         schema: GraphQLSchema,

     

       37
        
         typename: string,

     

       38
        
         fieldName: string

     

       39
        
       ): boolean => {

     

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

     

       41
        
         if (!field) return false;

     

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

     

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

     

       0
        
       
     

       44
        
       };

     

       45
        
       

     

       46
        
       export const isFieldAvailableOnType = (

     

       47
       -
         schema: GraphQLSchema,

     

       48
        
         typename: string,

     

       49
        
         fieldName: string

     

       50
        
       ): boolean => {

     
···

       53
        
       };

     

       54
        
       

     

       55
        
       export const isInterfaceOfType = (

     

       56
       -
         schema: GraphQLSchema,

     

       57
        
         node: InlineFragmentNode | FragmentDefinitionNode,

     

       58
        
         typename: string | void

     

       59
        
       ): boolean => {

     

       60
        
         if (!typename) return false;

     

       61
        
         const typeCondition = getTypeCondition(node);

     

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

     

       63
       -
       

     

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

     

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

     

       66
       -
       

     

       67
       -
         if (abstractType instanceof GraphQLObjectType) {

     

       68
       -
           return abstractType === objectType;

     

       69
       -
         }

     

       70
       -
       

     

       71
       -
         expectAbstractType(abstractType, typeCondition);

     

       72
       -
         expectObjectType(objectType, typename);

     

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

     

       74
        
       };

     

       75
        
       

     

       76
        
       const getField = (

     

       77
       -
         schema: GraphQLSchema,

     

       78
        
         typename: string,

     

       79
        
         fieldName: string

     

       80
        
       ) => {

     

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

     

       82
       -
         expectObjectType(object, typename);

     

       83
       -
       

     

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

     

       85
        
         if (!field) {

     

       86
        
           warn(

     

       87
        
             'Invalid field: The field `' +

     
···

       98
        
         return field;

     

       99
        
       };

     

       100
        
       

     

       101
       -
       function expectObjectType(

     

       102
       -
         x: any,

     

       103
       -
         typename: string

     

       104
       -
       ): asserts x is GraphQLObjectType {

     

       105
        
         invariant(

     

       106
       -
           x instanceof GraphQLObjectType,

     

       107
        
           'Invalid Object type: The type `' +

     

       108
        
             typename +

     

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

     
···

       112
        
         );

     

       113
        
       }

     

       114
        
       

     

       115
       -
       function expectAbstractType(

     

       116
       -
         x: any,

     

       117
       -
         typename: string

     

       118
       -
       ): asserts x is GraphQLAbstractType {

     

       119
        
         invariant(

     

       120
       -
           x instanceof GraphQLInterfaceType || x instanceof GraphQLUnionType,

     

       0
        
       
     

       0
        
       
     

       121
        
           'Invalid Abstract type: The type `' +

     

       122
        
             typename +

     

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

     
···

       127
        
       }

     

       128
        
       

     

       129
        
       export function expectValidKeyingConfig(

     

       130
       -
         schema: GraphQLSchema,

     

       131
        
         keys: KeyingConfig

     

       132
        
       ): void {

     

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

     

       134
       -
           const types = schema.getTypeMap();

     

       135
        
           for (const key in keys) {

     

       136
       -
             if (!types[key]) {

     

       137
        
               warn(

     

       138
        
                 'Invalid Object type: The type `' +

     

       139
        
                   key +

     
···

       146
        
       }

     

       147
        
       

     

       148
        
       export function expectValidUpdatesConfig(

     

       149
       -
         schema: GraphQLSchema,

     

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

     

       151
        
       ): void {

     

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

     

       153
        
           return;

     

       154
        
         }

     

       155
        
       

     

       156
       -
         const mutation = schema.getMutationType();

     

       157
       -
         const subscription = schema.getSubscriptionType();

     

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

     

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

     

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

     

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

     

       162
       -
       

     

       163
       -
         for (const fieldName in givenMutations) {

     

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

     

       165
       -
             warn(

     

       166
       -
               'Invalid mutation field: `' +

     

       167
       -
                 fieldName +

     

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

     

       169
       -
               21

     

       170
       -
             );

     

       171
        
           }

     

       172
        
         }

     

       173
        
       

     

       174
       -
         for (const fieldName in givenSubscription) {

     

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

     

       176
       -
             warn(

     

       177
       -
               'Invalid subscription field: `' +

     

       178
       -
                 fieldName +

     

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

     

       180
       -
               22

     

       181
       -
             );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       182
        
           }

     

       183
        
         }

     

       184
        
       }

     
···

       191
        
       }

     

       192
        
       

     

       193
        
       export function expectValidResolversConfig(

     

       194
       -
         schema: GraphQLSchema,

     

       195
        
         resolvers: ResolverConfig

     

       196
        
       ): void {

     

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

     

       198
        
           return;

     

       199
        
         }

     

       200
        
       

     

       201
       -
         const validTypes = schema.getTypeMap();

     

       202
        
         for (const key in resolvers) {

     

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

     

       204
       -
             const queryType = schema.getQueryType();

     

       205
       -
             if (queryType) {

     

       206
       -
               const validQueries = queryType.getFields();

     

       207
        
               for (const resolverQuery in resolvers.Query) {

     

       208
        
                 if (!validQueries[resolverQuery]) {

     

       209
        
                   warnAboutResolver('Query.' + resolverQuery);

     
···

       213
        
               warnAboutResolver('Query');

     

       214
        
             }

     

       215
        
           } else {

     

       216
       -
             if (!validTypes[key]) {

     

       217
        
               warnAboutResolver(key);

     

       218
        
             } else {

     

       219
       -
               const validTypeProperties = (schema.getType(

     

       220
       -
                 key

     

       221
       -
               ) as GraphQLObjectType).getFields();

     

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

     

       223
        
                 if (!validTypeProperties[resolverProperty]) {

     

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

     
···

       230
        
       }

     

       231
        
       

     

       232
        
       export function expectValidOptimisticMutationsConfig(

     

       233
       -
         schema: GraphQLSchema,

     

       234
        
         optimisticMutations: OptimisticMutationConfig

     

       235
        
       ): void {

     

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

     

       237
        
           return;

     

       238
        
         }

     

       239
        
       

     

       240
       -
         const validMutations = schema.getMutationType()

     

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

     

       242
       -
           : {};

     

       243
       -
       

     

       244
       -
         for (const mutation in optimisticMutations) {

     

       245
       -
           if (!validMutations[mutation]) {

     

       246
       -
             warn(

     

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

     

       248
       -
               24

     

       249
       -
             );

     

       250
        
           }

     

       251
        
         }

     

       252
        
       }

···

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2
        
       

     

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

     

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

     

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

     

       6
       +
       

     

       7
        
       import {

     

       8
        
         KeyingConfig,

     

       9
        
         UpdateResolver,

     
···

       14
        
       const BUILTIN_FIELD_RE = /^__/;

     

       15
        
       

     

       16
        
       export const isFieldNullable = (

     

       17
       +
         schema: SchemaIntrospector,

     

       18
        
         typename: string,

     

       19
        
         fieldName: string

     

       20
        
       ): boolean => {

     

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

     

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

     

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

     

       24
        
       };

     

       25
        
       

     

       26
        
       export const isListNullable = (

     

       27
       +
         schema: SchemaIntrospector,

     

       28
        
         typename: string,

     

       29
        
         fieldName: string

     

       30
        
       ): boolean => {

     

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

     

       32
        
         if (!field) return false;

     

       33
       +
         const ofType =

     

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

     

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

     

       36
        
       };

     

       37
        
       

     

       38
        
       export const isFieldAvailableOnType = (

     

       39
       +
         schema: SchemaIntrospector,

     

       40
        
         typename: string,

     

       41
        
         fieldName: string

     

       42
        
       ): boolean => {

     
···

       45
        
       };

     

       46
        
       

     

       47
        
       export const isInterfaceOfType = (

     

       48
       +
         schema: SchemaIntrospector,

     

       49
        
         node: InlineFragmentNode | FragmentDefinitionNode,

     

       50
        
         typename: string | void

     

       51
        
       ): boolean => {

     

       52
        
         if (!typename) return false;

     

       53
        
         const typeCondition = getTypeCondition(node);

     

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

     

       55
       +
         if (

     

       56
       +
           schema.types[typeCondition] &&

     

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

     

       58
       +
         )

     

       59
       +
           return typeCondition === typename;

     

       60
       +
         expectAbstractType(schema, typeCondition!);

     

       61
       +
         expectObjectType(schema, typename!);

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       63
        
       };

     

       64
        
       

     

       65
        
       const getField = (

     

       66
       +
         schema: SchemaIntrospector,

     

       67
        
         typename: string,

     

       68
        
         fieldName: string

     

       69
        
       ) => {

     

       70
       +
         expectObjectType(schema, typename);

     

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

     

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

     

       0
        
       
     

       73
        
         if (!field) {

     

       74
        
           warn(

     

       75
        
             'Invalid field: The field `' +

     
···

       86
        
         return field;

     

       87
        
       };

     

       88
        
       

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       90
        
         invariant(

     

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

     

       92
        
           'Invalid Object type: The type `' +

     

       93
        
             typename +

     

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

     
···

       97
        
         );

     

       98
        
       }

     

       99
        
       

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       101
        
         invariant(

     

       102
       +
           schema.types[typename] &&

     

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

     

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

     

       105
        
           'Invalid Abstract type: The type `' +

     

       106
        
             typename +

     

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

     
···

       111
        
       }

     

       112
        
       

     

       113
        
       export function expectValidKeyingConfig(

     

       114
       +
         schema: SchemaIntrospector,

     

       115
        
         keys: KeyingConfig

     

       116
        
       ): void {

     

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

     

       0
        
       
     

       118
        
           for (const key in keys) {

     

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

     

       120
        
               warn(

     

       121
        
                 'Invalid Object type: The type `' +

     

       122
        
                   key +

     
···

       129
        
       }

     

       130
        
       

     

       131
        
       export function expectValidUpdatesConfig(

     

       132
       +
         schema: SchemaIntrospector,

     

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

     

       134
        
       ): void {

     

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

     

       136
        
           return;

     

       137
        
         }

     

       138
        
       

     

       139
       +
         if (schema.mutation) {

     

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

     

       141
       +
             .fields;

     

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

     

       143
       +
           for (const fieldName in givenMutations) {

     

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

     

       145
       +
               warn(

     

       146
       +
                 'Invalid mutation field: `' +

     

       147
       +
                   fieldName +

     

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

     

       149
       +
                 21

     

       150
       +
               );

     

       151
       +
             }

     

       0
        
       
     

       0
        
       
     

       152
        
           }

     

       153
        
         }

     

       154
        
       

     

       155
       +
         if (schema.subscription) {

     

       156
       +
           const subscriptionFields = (schema.types[

     

       157
       +
             schema.subscription

     

       158
       +
           ] as SchemaObject).fields;

     

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

     

       160
       +
           for (const fieldName in givenSubscription) {

     

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

     

       162
       +
               warn(

     

       163
       +
                 'Invalid subscription field: `' +

     

       164
       +
                   fieldName +

     

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

     

       166
       +
                 22

     

       167
       +
               );

     

       168
       +
             }

     

       169
        
           }

     

       170
        
         }

     

       171
        
       }

     
···

       178
        
       }

     

       179
        
       

     

       180
        
       export function expectValidResolversConfig(

     

       181
       +
         schema: SchemaIntrospector,

     

       182
        
         resolvers: ResolverConfig

     

       183
        
       ): void {

     

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

     

       185
        
           return;

     

       186
        
         }

     

       187
        
       

     

       0
        
       
     

       188
        
         for (const key in resolvers) {

     

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

     

       190
       +
             if (schema.query) {

     

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

     

       192
       +
                 .fields;

     

       193
        
               for (const resolverQuery in resolvers.Query) {

     

       194
        
                 if (!validQueries[resolverQuery]) {

     

       195
        
                   warnAboutResolver('Query.' + resolverQuery);

     
···

       199
        
               warnAboutResolver('Query');

     

       200
        
             }

     

       201
        
           } else {

     

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

     

       203
        
               warnAboutResolver(key);

     

       204
        
             } else {

     

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

     

       0
        
       
     

       0
        
       
     

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

     

       207
        
                 if (!validTypeProperties[resolverProperty]) {

     

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

     
···

       214
        
       }

     

       215
        
       

     

       216
        
       export function expectValidOptimisticMutationsConfig(

     

       217
       +
         schema: SchemaIntrospector,

     

       218
        
         optimisticMutations: OptimisticMutationConfig

     

       219
        
       ): void {

     

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

     

       221
        
           return;

     

       222
        
         }

     

       223
        
       

     

       224
       +
         if (schema.mutation) {

     

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

     

       226
       +
             .fields;

     

       227
       +
           for (const mutation in optimisticMutations) {

     

       228
       +
             if (!validMutations[mutation]) {

     

       229
       +
               warn(

     

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

     

       231
       +
                 24

     

       232
       +
               );

     

       233
       +
             }

     

       234
        
           }

     

       235
        
         }

     

       236
        
       }

+18 -20

exchanges/graphcache/src/store/store.ts

···

       1
       -
       import {

     

       2
       -
         buildClientSchema,

     

       3
       -
         DocumentNode,

     

       4
       -
         IntrospectionQuery,

     

       5
       -
         GraphQLSchema,

     

       6
       -
       } from 'graphql';

     

       7
        
       

     

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

     

       9
        
       

     
···

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

     

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

     

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

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       31
        
       

     

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

     

       33
        
       

     
···

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

     

       47
        
         optimisticMutations: OptimisticMutationConfig;

     

       48
        
         keys: KeyingConfig;

     

       49
       -
         schema?: GraphQLSchema;

     

       50
        
       

     

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

     

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

     
···

       63
        
           let subscriptionName = 'Subscription';

     

       64
        
           if (opts.schema) {

     

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

     

       66
       -
             const queryType = schema.getQueryType();

     

       67
       -
             const mutationType = schema.getMutationType();

     

       68
       -
             const subscriptionType = schema.getSubscriptionType();

     

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

     

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

     

       71
       -
             subscriptionName = subscriptionType

     

       72
       -
               ? subscriptionType.name

     

       73
       -
               : subscriptionName;

     

       74
        
           }

     

       75
        
       

     

       76
        
           this.updates = {

     
···

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

     

       94
        
       

     

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

     

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

     

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

     

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

     

       99
       -
             SchemaPredicates.expectValidOptimisticMutationsConfig(

     

       100
        
               this.schema,

     

       101
        
               this.optimisticMutations

     

       102
        
             );

···

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2
        
       

     

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

     

       4
        
       

     
···

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

     

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

     

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

     

       25
       +
       

     

       26
       +
       import {

     

       27
       +
         SchemaIntrospector,

     

       28
       +
         buildClientSchema,

     

       29
       +
         expectValidKeyingConfig,

     

       30
       +
         expectValidUpdatesConfig,

     

       31
       +
         expectValidResolversConfig,

     

       32
       +
         expectValidOptimisticMutationsConfig,

     

       33
       +
       } from '../ast';

     

       34
        
       

     

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

     

       36
        
       

     
···

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

     

       50
        
         optimisticMutations: OptimisticMutationConfig;

     

       51
        
         keys: KeyingConfig;

     

       52
       +
         schema?: SchemaIntrospector;

     

       53
        
       

     

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

     

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

     
···

       66
        
           let subscriptionName = 'Subscription';

     

       67
        
           if (opts.schema) {

     

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

     

       69
       +
             queryName = schema.query || queryName;

     

       70
       +
             mutationName = schema.mutation || mutationName;

     

       71
       +
             subscriptionName = schema.subscription || subscriptionName;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       72
        
           }

     

       73
        
       

     

       74
        
           this.updates = {

     
···

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

     

       92
        
       

     

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

     

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

     

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

     

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

     

       97
       +
             expectValidOptimisticMutationsConfig(

     

       98
        
               this.schema,

     

       99
        
               this.optimisticMutations

     

       100
        
             );