+3 -2

.changeset/thick-avocados-enjoy.md

reviewed

··· 2 2 '@urql/exchange-graphcache': minor 3 3 --- 4 4 5 5 - Issue warnings when an unknown type has been included in Graphcache's opts.key configuration to help spot typos. 6 6 - See: [#820](https://github.com/FormidableLabs/urql/pull/820) 5 5 + Issue warnings when an unknown type or field has been included in Graphcache's `opts` configuration to help spot typos. 6 6 + Checks `opts.keys`, `opts.updates`, `opts.resolvers` and `opts.optimistic`. 7 7 + See: [#820](https://github.com/FormidableLabs/urql/pull/820) and [#826](https://github.com/FormidableLabs/urql/pull/826)

+43

docs/graphcache/errors.md

reviewed

··· 289 289 290 290 Check whether your schema is up-to-date, or whether you're using an invalid 291 291 typename in `opts.keys`, maybe due to a typo. 292 292 + 293 293 + ## (21) Invalid mutation 294 294 + 295 295 + > Invalid mutation field `???` is not in the defined schema but the `updates` option is referencing it. 296 296 + 297 297 + When you're passing an introspected schema to the cache exchange, it is 298 298 + able to check whether your `opts.updates.Mutation` is valid. 299 299 + This error occurs when an unknown mutation field is found in `opts.updates.Mutation`. 300 300 + 301 301 + Check whether your schema is up-to-date, or whether you've got a typo in `opts.updates.Mutation`. 302 302 + 303 303 + ## (22) Invalid subscription 304 304 + 305 305 + > Invalid subscription field: `???` is not in the defined schema but the `updates` option is referencing it. 306 306 + 307 307 + When you're passing an introspected schema to the cache exchange, it is 308 308 + able to check whether your `opts.updates.Subscription` is valid. 309 309 + This error occurs when an unknown subscription field is found in `opts.updates.Subscription`. 310 310 + 311 311 + Check whether your schema is up-to-date, or whether you're using an invalid 312 312 + subscription name in `opts.updates.Subscription`, maybe due to a typo. 313 313 + 314 314 + ## (23) Invalid resolver 315 315 + 316 316 + > Invalid resolver: `???` is not in the defined schema, but the `resolvers` 317 317 + > option is referencing it. 318 318 + 319 319 + When you're passing an introspected schema to the cache exchange, it is 320 320 + able to check whether your `opts.resolvers` is valid. 321 321 + This error occurs when an unknown query, type or field is found in `opts.resolvers`. 322 322 + 323 323 + Check whether your schema is up-to-date, or whether you've got a typo in `opts.resolvers`. 324 324 + 325 325 + ## (24) Invalid optimistic mutation 326 326 + 327 327 + > Invalid optimistic mutation field: `???` is not a mutation field in the defined schema, 328 328 + > but the `optimistic` option is referencing it. 329 329 + 330 330 + When you're passing an introspected schema to the cache exchange, it is 331 331 + able to check whether your `opts.optimistic` is valid. 332 332 + This error occurs when a field in `opts.optimistic` is not in the schema's `Mutation` fields. 333 333 + 334 334 + Check whether your schema is up-to-date, or whether you've got a typo in `Mutation` or `opts.optimistic`.

+124 -1

exchanges/graphcache/src/ast/schemaPredicates.ts

reviewed

··· 10 10 } from 'graphql'; 11 11 12 12 import { warn, invariant } from '../helpers/help'; 13 13 - import { KeyingConfig } from '../types'; 13 13 + import { 14 14 + KeyingConfig, 15 15 + UpdatesConfig, 16 16 + ResolverConfig, 17 17 + OptimisticMutationConfig, 18 18 + } from '../types'; 14 19 15 20 export const isFieldNullable = ( 16 21 schema: GraphQLSchema, ··· 131 136 }); 132 137 } 133 138 } 139 139 + 140 140 + export function expectValidUpdatesConfig( 141 141 + schema: GraphQLSchema, 142 142 + updates: UpdatesConfig 143 143 + ): void { 144 144 + if (process.env.NODE_ENV === 'production') { 145 145 + return; 146 146 + } 147 147 + 148 148 + /* eslint-disable prettier/prettier */ 149 149 + const schemaMutations = schema.getMutationType() 150 150 + ? Object.keys((schema.getMutationType() as GraphQLObjectType).toConfig().fields) 151 151 + : []; 152 152 + const schemaSubscriptions = schema.getSubscriptionType() 153 153 + ? Object.keys((schema.getSubscriptionType() as GraphQLObjectType).toConfig().fields) 154 154 + : []; 155 155 + const givenMutations = updates.Mutation 156 156 + ? Object.keys(updates.Mutation) 157 157 + : []; 158 158 + const givenSubscriptions = updates.Subscription 159 159 + ? Object.keys(updates.Subscription) 160 160 + : []; 161 161 + /* eslint-enable prettier/prettier */ 162 162 + 163 163 + for (const givenMutation of givenMutations) { 164 164 + if (schemaMutations.indexOf(givenMutation) === -1) { 165 165 + warn( 166 166 + 'Invalid mutation field: `' + 167 167 + givenMutation + 168 168 + '` is not in the defined schema, but the `updates.Mutation` option is referencing it.', 169 169 + 21 170 170 + ); 171 171 + } 172 172 + } 173 173 + 174 174 + for (const givenSubscription of givenSubscriptions) { 175 175 + if (schemaSubscriptions.indexOf(givenSubscription) === -1) { 176 176 + warn( 177 177 + 'Invalid subscription field: `' + 178 178 + givenSubscription + 179 179 + '` is not in the defined schema, but the `updates.Subscription` option is referencing it.', 180 180 + 22 181 181 + ); 182 182 + } 183 183 + } 184 184 + } 185 185 + 186 186 + function warnAboutResolver(name: string): void { 187 187 + warn( 188 188 + `Invalid resolver: \`${name}\` is not in the defined schema, but the \`resolvers\` option is referencing it.`, 189 189 + 23 190 190 + ); 191 191 + } 192 192 + 193 193 + export function expectValidResolversConfig( 194 194 + schema: GraphQLSchema, 195 195 + resolvers: ResolverConfig 196 196 + ): void { 197 197 + if (process.env.NODE_ENV === 'production') { 198 198 + return; 199 199 + } 200 200 + 201 201 + const validTypes = Object.keys(schema.getTypeMap()); 202 202 + 203 203 + for (const key in resolvers) { 204 204 + if (key === 'Query') { 205 205 + const queryType = schema.getQueryType(); 206 206 + if (queryType) { 207 207 + const validQueries = Object.keys(queryType.toConfig().fields); 208 208 + for (const resolverQuery in resolvers.Query) { 209 209 + if (validQueries.indexOf(resolverQuery) === -1) { 210 210 + warnAboutResolver('Query.' + resolverQuery); 211 211 + } 212 212 + } 213 213 + } else { 214 214 + warnAboutResolver('Query'); 215 215 + } 216 216 + } else { 217 217 + if (validTypes.indexOf(key) === -1) { 218 218 + warnAboutResolver(key); 219 219 + } else { 220 220 + const validTypeProperties = Object.keys( 221 221 + (schema.getType(key) as GraphQLObjectType).getFields() 222 222 + ); 223 223 + const resolverProperties = Object.keys(resolvers[key]); 224 224 + for (const resolverProperty of resolverProperties) { 225 225 + if (validTypeProperties.indexOf(resolverProperty) === -1) { 226 226 + warnAboutResolver(key + '.' + resolverProperty); 227 227 + } 228 228 + } 229 229 + } 230 230 + } 231 231 + } 232 232 + } 233 233 + 234 234 + export function expectValidOptimisticMutationsConfig( 235 235 + schema: GraphQLSchema, 236 236 + optimisticMutations: OptimisticMutationConfig 237 237 + ): void { 238 238 + if (process.env.NODE_ENV === 'production') { 239 239 + return; 240 240 + } 241 241 + 242 242 + const validMutations = schema.getMutationType() 243 243 + ? Object.keys( 244 244 + (schema.getMutationType() as GraphQLObjectType).toConfig().fields 245 245 + ) 246 246 + : []; 247 247 + 248 248 + for (const mutation in optimisticMutations) { 249 249 + if (validMutations.indexOf(mutation) === -1) { 250 250 + warn( 251 251 + `Invalid optimistic mutation field: \`${mutation}\` is not a mutation field in the defined schema, but the \`optimistic\` option is referencing it.`, 252 252 + 24 253 253 + ); 254 254 + } 255 255 + } 256 256 + }

+5 -1

exchanges/graphcache/src/helpers/help.ts

reviewed

··· 24 24 | 17 25 25 | 18 26 26 | 19 27 27 - | 20; 27 27 + | 20 28 28 + | 21 29 29 + | 22 30 30 + | 23 31 31 + | 24; 28 32 29 33 type DebugNode = ExecutableDefinitionNode | InlineFragmentNode; 30 34

+9 -2

exchanges/graphcache/src/operations/query.test.ts

reviewed

··· 41 41 ], 42 42 } 43 43 ); 44 44 - 45 45 - jest.resetAllMocks(); 46 44 }); 47 45 48 46 it('test partial results', () => { ··· 155 153 __typename: 'Query', 156 154 todos: [{ __typename: 'Todo', id: '0', text: 'Solve bug' }], 157 155 }); 156 156 + 157 157 + expect(console.warn).not.toHaveBeenCalled(); 158 158 + expect(console.error).not.toHaveBeenCalled(); 158 159 }); 159 160 160 161 it('should respect altered root types', () => { ··· 186 187 __typename: 'query_root', 187 188 todos: [{ __typename: 'Todo', id: '0', text: 'Solve bug' }], 188 189 }); 190 190 + 191 191 + expect(console.warn).not.toHaveBeenCalled(); 192 192 + expect(console.error).not.toHaveBeenCalled(); 189 193 }); 190 194 191 195 it('should allow subsequent read when first result was null', () => { ··· 247 251 __typename: 'query_root', 248 252 todos: [null], 249 253 }); 254 254 + 255 255 + expect(console.warn).not.toHaveBeenCalled(); 256 256 + expect(console.error).not.toHaveBeenCalled(); 250 257 }); 251 258 });

+36 -3

exchanges/graphcache/src/operations/write.test.ts

reviewed

··· 44 44 jest.clearAllMocks(); 45 45 }); 46 46 47 47 + it('should not crash for valid writes', async () => { 48 48 + const VALID_TODO_QUERY = gql` 49 49 + mutation { 50 50 + toggleTodo { 51 51 + id 52 52 + text 53 53 + complete 54 54 + } 55 55 + } 56 56 + `; 57 57 + write( 58 58 + store, 59 59 + { query: VALID_TODO_QUERY }, 60 60 + { 61 61 + __typename: 'Mutation', 62 62 + toggleTodo: { 63 63 + __typename: 'Todo', 64 64 + id: '0', 65 65 + text: 'Teach', 66 66 + complete: true, 67 67 + }, 68 68 + } 69 69 + ); 70 70 + expect(console.warn).not.toHaveBeenCalled(); 71 71 + expect(console.error).not.toHaveBeenCalled(); 72 72 + }); 73 73 + 47 74 it('should warn once for invalid fields on an entity', () => { 48 75 const INVALID_TODO_QUERY = gql` 49 76 mutation { ··· 82 109 } 83 110 ); 84 111 expect(console.warn).toHaveBeenCalledTimes(1); 85 85 - expect((console.warn as any).mock.calls[0][0]).toMatch(/incomplete/); 112 112 + expect((console.warn as any).mock.calls[0][0]).toMatch( 113 113 + /The field `incomplete` does not exist on `Todo`/ 114 114 + ); 86 115 }); 87 116 88 117 it('should warn once for invalid fields on an entity', () => { ··· 131 160 ); 132 161 133 162 expect(console.warn).toHaveBeenCalledTimes(1); 134 134 - expect((console.warn as any).mock.calls[0][0]).toMatch(/writer/); 163 163 + expect((console.warn as any).mock.calls[0][0]).toMatch( 164 164 + /The field `writer` does not exist on `Todo`/ 165 165 + ); 135 166 }); 136 167 137 168 it('should skip undefined values that are expected', () => { ··· 146 177 write(store, { query }, { field: undefined } as any); 147 178 // Because of us writing an undefined field 148 179 expect(console.warn).toHaveBeenCalledTimes(2); 149 149 - expect((console.warn as any).mock.calls[0][0]).toMatch(/undefined/); 180 180 + expect((console.warn as any).mock.calls[0][0]).toMatch( 181 181 + /The field `field` does not exist on `Query`/ 182 182 + ); 150 183 151 184 InMemoryData.initDataState(store.data, null); 152 185 // The field must still be `'test'`

+207 -2

exchanges/graphcache/src/store/store.test.ts

reviewed

··· 5 5 import { write, writeOptimistic } from '../operations/write'; 6 6 import * as InMemoryData from './data'; 7 7 import { Store } from './store'; 8 8 + import { noop } from '../test-utils/utils'; 8 9 9 10 const Appointment = gql` 10 11 query appointment($id: String) { ··· 91 92 }); 92 93 }); 93 94 95 95 + describe('Store with UpdatesConfig', () => { 96 96 + it("sets the store's updates field to the given argument", () => { 97 97 + const updatesOption = { 98 98 + Mutation: { 99 99 + toggleTodo: noop, 100 100 + }, 101 101 + Subscription: { 102 102 + newTodo: noop, 103 103 + }, 104 104 + }; 105 105 + 106 106 + const store = new Store({ 107 107 + updates: updatesOption, 108 108 + }); 109 109 + 110 110 + expect(store.updates.Mutation).toBe(updatesOption.Mutation); 111 111 + expect(store.updates.Subscription).toBe(updatesOption.Subscription); 112 112 + }); 113 113 + 114 114 + it("sets the store's updates field to an empty default if not provided", () => { 115 115 + const store = new Store({}); 116 116 + 117 117 + expect(store.updates.Mutation).toEqual({}); 118 118 + expect(store.updates.Subscription).toEqual({}); 119 119 + }); 120 120 + 121 121 + it('should not warn if Mutation/Subscription operations do exist in the schema', function () { 122 122 + new Store({ 123 123 + schema: require('../test-utils/simple_schema.json'), 124 124 + updates: { 125 125 + Mutation: { 126 126 + toggleTodo: noop, 127 127 + }, 128 128 + Subscription: { 129 129 + newTodo: noop, 130 130 + }, 131 131 + }, 132 132 + }); 133 133 + 134 134 + expect(console.warn).not.toBeCalled(); 135 135 + }); 136 136 + 137 137 + it("should warn if Mutation operations don't exist in the schema", function () { 138 138 + new Store({ 139 139 + schema: require('../test-utils/simple_schema.json'), 140 140 + updates: { 141 141 + Mutation: { 142 142 + doTheChaChaSlide: noop, 143 143 + }, 144 144 + }, 145 145 + }); 146 146 + 147 147 + expect(console.warn).toBeCalledTimes(1); 148 148 + const warnMessage = mocked(console.warn).mock.calls[0][0]; 149 149 + expect(warnMessage).toContain( 150 150 + 'Invalid mutation field: `doTheChaChaSlide` is not in the defined schema, but the `updates.Mutation` option is referencing it.' 151 151 + ); 152 152 + expect(warnMessage).toContain('https://bit.ly/2XbVrpR#21'); 153 153 + }); 154 154 + 155 155 + it("should warn if Subscription operations don't exist in the schema", function () { 156 156 + new Store({ 157 157 + schema: require('../test-utils/simple_schema.json'), 158 158 + updates: { 159 159 + Subscription: { 160 160 + someoneDidTheChaChaSlide: noop, 161 161 + }, 162 162 + }, 163 163 + }); 164 164 + 165 165 + expect(console.warn).toBeCalledTimes(1); 166 166 + const warnMessage = mocked(console.warn).mock.calls[0][0]; 167 167 + expect(warnMessage).toContain( 168 168 + 'Invalid subscription field: `someoneDidTheChaChaSlide` is not in the defined schema, but the `updates.Subscription` option is referencing it.' 169 169 + ); 170 170 + expect(warnMessage).toContain('https://bit.ly/2XbVrpR#22'); 171 171 + }); 172 172 + }); 173 173 + 94 174 describe('Store with KeyingConfig', () => { 95 175 it('generates keys from custom keying function', () => { 96 176 const store = new Store({ ··· 138 218 }); 139 219 }); 140 220 221 221 + describe('Store with ResolverConfig', () => { 222 222 + it("sets the store's resolvers field to the given argument", () => { 223 223 + const resolversOption = { 224 224 + Query: { 225 225 + latestTodo: () => 'todo', 226 226 + }, 227 227 + }; 228 228 + 229 229 + const store = new Store({ 230 230 + resolvers: resolversOption, 231 231 + }); 232 232 + 233 233 + expect(store.resolvers).toBe(resolversOption); 234 234 + }); 235 235 + 236 236 + it("sets the store's resolvers field to an empty default if not provided", () => { 237 237 + const store = new Store({}); 238 238 + 239 239 + expect(store.resolvers).toEqual({}); 240 240 + }); 241 241 + 242 242 + it('should not warn if resolvers do exist in the schema', function () { 243 243 + new Store({ 244 244 + schema: require('../test-utils/simple_schema.json'), 245 245 + resolvers: { 246 246 + Query: { 247 247 + latestTodo: () => 'todo', 248 248 + todos: () => ['todo 1', 'todo 2'], 249 249 + }, 250 250 + Todo: { 251 251 + text: todo => (todo.text as string).toUpperCase(), 252 252 + author: todo => (todo.author as string).toUpperCase(), 253 253 + }, 254 254 + }, 255 255 + }); 256 256 + 257 257 + expect(console.warn).not.toBeCalled(); 258 258 + }); 259 259 + 260 260 + it("should warn if a Query doesn't exist in the schema", function () { 261 261 + new Store({ 262 262 + schema: require('../test-utils/simple_schema.json'), 263 263 + resolvers: { 264 264 + Query: { 265 265 + todos: () => ['todo 1', 'todo 2'], 266 266 + // This query should be warned about. 267 267 + findDeletedTodos: () => ['todo 1', 'todo 2'], 268 268 + }, 269 269 + }, 270 270 + }); 271 271 + 272 272 + expect(console.warn).toBeCalledTimes(1); 273 273 + const warnMessage = mocked(console.warn).mock.calls[0][0]; 274 274 + expect(warnMessage).toContain( 275 275 + 'Invalid resolver: `Query.findDeletedTodos` is not in the defined schema, but the `resolvers` option is referencing it' 276 276 + ); 277 277 + expect(warnMessage).toContain('https://bit.ly/2XbVrpR#23'); 278 278 + }); 279 279 + 280 280 + it("should warn if a type doesn't exist in the schema", function () { 281 281 + new Store({ 282 282 + schema: require('../test-utils/simple_schema.json'), 283 283 + resolvers: { 284 284 + Todo: { 285 285 + complete: () => true, 286 286 + }, 287 287 + // This type should be warned about. 288 288 + Dinosaur: { 289 289 + isExtinct: () => true, 290 290 + }, 291 291 + }, 292 292 + }); 293 293 + 294 294 + expect(console.warn).toBeCalledTimes(1); 295 295 + const warnMessage = mocked(console.warn).mock.calls[0][0]; 296 296 + expect(warnMessage).toContain( 297 297 + 'Invalid resolver: `Dinosaur` is not in the defined schema, but the `resolvers` option is referencing it' 298 298 + ); 299 299 + expect(warnMessage).toContain('https://bit.ly/2XbVrpR#23'); 300 300 + }); 301 301 + 302 302 + it("should warn if a type's property doesn't exist in the schema", function () { 303 303 + new Store({ 304 304 + schema: require('../test-utils/simple_schema.json'), 305 305 + resolvers: { 306 306 + Todo: { 307 307 + complete: () => true, 308 308 + // This property should be warned about. 309 309 + isAboutDinosaurs: () => true, 310 310 + }, 311 311 + }, 312 312 + }); 313 313 + 314 314 + expect(console.warn).toBeCalledTimes(1); 315 315 + const warnMessage = mocked(console.warn).mock.calls[0][0]; 316 316 + expect(warnMessage).toContain( 317 317 + 'Invalid resolver: `Todo.isAboutDinosaurs` is not in the defined schema, but the `resolvers` option is referencing it' 318 318 + ); 319 319 + expect(warnMessage).toContain('https://bit.ly/2XbVrpR#23'); 320 320 + }); 321 321 + }); 322 322 + 141 323 describe('Store with OptimisticMutationConfig', () => { 142 324 let store; 143 325 ··· 156 338 InMemoryData.initDataState(store.data, null); 157 339 }); 158 340 159 159 - it('Should resolve a property', () => { 341 341 + it('should resolve a property', () => { 160 342 const todoResult = store.resolve({ __typename: 'Todo', id: '0' }, 'text'); 161 343 expect(todoResult).toEqual('Go to the shops'); 162 344 const authorResult = store.resolve( ··· 180 362 InMemoryData.clearDataState(); 181 363 }); 182 364 183 183 - it('Should resolve a link property', () => { 365 365 + it('should resolve a link property', () => { 184 366 const parent = { 185 367 id: '0', 186 368 text: 'test', ··· 658 840 InMemoryData.initDataState(store.data, null); 659 841 expect(InMemoryData.readRecord('Query', 'base')).toBe(true); 660 842 InMemoryData.clearDataState(); 843 843 + }); 844 844 + 845 845 + it("should warn if an optimistic field doesn't exist in the schema's mutations", function () { 846 846 + new Store({ 847 847 + schema: require('../test-utils/simple_schema.json'), 848 848 + updates: { 849 849 + Mutation: { 850 850 + toggleTodo: noop, 851 851 + }, 852 852 + }, 853 853 + optimistic: { 854 854 + toggleTodo: () => null, 855 855 + // This field should be warned about. 856 856 + deleteTodo: () => null, 857 857 + }, 858 858 + }); 859 859 + 860 860 + expect(console.warn).toBeCalledTimes(1); 861 861 + const warnMessage = mocked(console.warn).mock.calls[0][0]; 862 862 + expect(warnMessage).toContain( 863 863 + 'Invalid optimistic mutation field: `deleteTodo` is not a mutation field in the defined schema, but the `optimistic` option is referencing it.' 864 864 + ); 865 865 + expect(warnMessage).toContain('https://bit.ly/2XbVrpR#24'); 661 866 }); 662 867 });

+25 -2

exchanges/graphcache/src/store/store.ts

reviewed

··· 75 75 if (mutationType) mutationName = mutationType.name; 76 76 if (subscriptionType) subscriptionName = subscriptionType.name; 77 77 78 78 - if (this.keys) { 79 79 - SchemaPredicates.expectValidKeyingConfig(this.schema, this.keys); 78 78 + if (process.env.NODE_ENV !== 'production') { 79 79 + if (this.keys) { 80 80 + SchemaPredicates.expectValidKeyingConfig(this.schema, this.keys); 81 81 + } 82 82 + 83 83 + const hasUpdates = 84 84 + Object.keys(this.updates.Mutation).length > 0 || 85 85 + Object.keys(this.updates.Subscription).length > 0; 86 86 + if (hasUpdates) { 87 87 + SchemaPredicates.expectValidUpdatesConfig(this.schema, this.updates); 88 88 + } 89 89 + 90 90 + if (this.resolvers) { 91 91 + SchemaPredicates.expectValidResolversConfig( 92 92 + this.schema, 93 93 + this.resolvers 94 94 + ); 95 95 + } 96 96 + 97 97 + if (this.optimisticMutations) { 98 98 + SchemaPredicates.expectValidOptimisticMutationsConfig( 99 99 + this.schema, 100 100 + this.optimisticMutations 101 101 + ); 102 102 + } 80 103 } 81 104 } 82 105

+24 -1

exchanges/graphcache/src/test-utils/simple_schema.json

reviewed

··· 6 6 "mutationType": { 7 7 "name": "Mutation" 8 8 }, 9 9 - "subscriptionType": null, 9 9 + "subscriptionType": { 10 10 + "name": "Subscription" 11 11 + }, 10 12 "types": [ 11 13 { 12 14 "kind": "OBJECT", ··· 234 236 "name": "Todo", 235 237 "ofType": null 236 238 } 239 239 + } 240 240 + ], 241 241 + "inputFields": null, 242 242 + "interfaces": [], 243 243 + "enumValues": null, 244 244 + "possibleTypes": null 245 245 + }, 246 246 + { 247 247 + "kind": "OBJECT", 248 248 + "name": "Subscription", 249 249 + "fields": [ 250 250 + { 251 251 + "name": "newTodo", 252 252 + "args": [], 253 253 + "type": { 254 254 + "kind": "OBJECT", 255 255 + "name": "Todo", 256 256 + "ofType": null 257 257 + }, 258 258 + "isDeprecated": false, 259 259 + "deprecationReason": null 237 260 } 238 261 ], 239 262 "inputFields": null,

+2

exchanges/graphcache/src/test-utils/utils.ts

reviewed

··· 1 1 + // eslint-disable-next-line 2 2 + export const noop = () => {};

+1

scripts/jest/preset.js

reviewed

··· 3 3 setupFiles: [ 4 4 require.resolve('./setup.js') 5 5 ], 6 6 + clearMocks: true, 6 7 transform: { 7 8 '^.+\\.tsx?$': 'ts-jest', 8 9 },

+2 -2

scripts/jest/setup.js

reviewed

··· 1 1 + // This script is run before each `.test.ts` file. 2 2 + 1 3 global.AbortController = undefined; 2 4 global.fetch = jest.fn(); 3 5 4 6 process.on('unhandledRejection', error => { 5 7 throw error; 6 8 }); 7 7 - 8 8 - jest.restoreAllMocks(); 9 9 10 10 const originalConsole = console; 11 11 global.console = {