commit d845f88bd6b3529666776d315ebcd3d27f61ac23 · kitten.sh/urql

.changeset/orange-rabbits-poke.md

···

       1
       1
       +
       ---

     

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

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Don't serialize data to IDB. This invalidates all existing data, but greatly improves performance of read/write operations.

+6 -52

exchanges/graphcache/src/default-storage/index.ts

···

       78
       78
        
           req.result.createObjectStore(METADATA_STORE_NAME);

     

       79
       79
        
         };

     

       80
       80
        
       

     

       81
       81
       -
         const serializeEntry = (entry: string): string => entry.replace(/:/g, '%3a');

     

       82
       82
       -
       

     

       83
       83
       -
         const deserializeEntry = (entry: string): string =>

     

       84
       84
       -
           entry.replace(/%3a/g, ':');

     

       85
       85
       -
       

     

       86
       86
       -
         const serializeBatch = (): string => {

     

       87
       87
       -
           let data = '';

     

       88
       88
       -
           for (const key in batch) {

     

       89
       89
       -
             const value = batch[key];

     

       90
       90
       -
             data += serializeEntry(key);

     

       91
       91
       -
             data += ':';

     

       92
       92
       -
             if (value) data += serializeEntry(value);

     

       93
       93
       -
             data += ':';

     

       94
       94
       -
           }

     

       95
       95
       -
       

     

       96
       96
       -
           return data;

     

       97
       97
       -
         };

     

       98
       98
       -
       

     

       99
       99
       -
         const deserializeBatch = (input: string) => {

     

       100
       100
       -
           const data = {};

     

       101
       101
       -
           let char = '';

     

       102
       102
       -
           let key = '';

     

       103
       103
       -
           let entry = '';

     

       104
       104
       -
           let mode = 0;

     

       105
       105
       -
           let index = 0;

     

       106
       106
       -
           while (index < input.length) {

     

       107
       107
       -
             entry = '';

     

       108
       108
       -
             while ((char = input[index++]) !== ':' && char) {

     

       109
       109
       -
               entry += char;

     

       110
       110
       -
             }

     

       111
       111
       -
       

     

       112
       112
       -
             if (mode) {

     

       113
       113
       -
               data[key] = deserializeEntry(entry) || undefined;

     

       114
       114
       -
               mode = 0;

     

       115
       115
       -
             } else {

     

       116
       116
       -
               key = deserializeEntry(entry);

     

       117
       117
       -
               mode = 1;

     

       118
       118
       -
             }

     

       119
       119
       -
           }

     

       120
       120
       -
       

     

       121
       121
       -
           return data;

     

       122
       122
       -
         };

     

       123
       123
       -
       

     

       124
       81
        
         return {

     

       125
       82
        
           clear() {

     

       126
       83
        
             return database$.then(database => {

     
···

       175
       132
        
                   database

     

       176
       133
        
                     .transaction(ENTRIES_STORE_NAME, 'readwrite')

     

       177
       134
        
                     .objectStore(ENTRIES_STORE_NAME)

     

       178
       178
       -
                     .put(serializeBatch(), timestamp)

     

       135
       135
       +
                     .put(batch, timestamp)

     

       179
       136
        
                 );

     

       180
       137
        
               })

     

       181
       138
        
               .then(toUndefined, toUndefined);

     

       182
       139
        
           },

     

       183
       140
        
       

     

       184
       141
        
           readData(): Promise<SerializedEntries> {

     

       185
       185
       -
             const chunks: string[] = [];

     

       142
       142
       +
             const data: SerializedEntries = {};

     

       186
       143
        
             return database$

     

       187
       144
        
               .then(database => {

     

       188
       145
        
                 const transaction = database.transaction(

     
···

       200
       157
        
                       store.delete(key);

     

       201
       158
        
                     } else {

     

       202
       159
        
                       const request = store.get(key);

     

       203
       203
       -
                       const index = chunks.length;

     

       204
       204
       -
                       chunks.push('');

     

       205
       160
        
                       request.onsuccess = () => {

     

       206
       206
       -
                         const result = '' + request.result;

     

       207
       207
       -
                         if (key === timestamp)

     

       208
       208
       -
                           Object.assign(batch, deserializeBatch(result));

     

       209
       209
       -
                         chunks[index] = result;

     

       161
       161
       +
                         const result = request.result;

     

       162
       162
       +
                         if (key === timestamp) Object.assign(batch, result);

     

       163
       163
       +
                         Object.assign(data, result);

     

       210
       164
        
                       };

     

       211
       165
        
                     }

     

       212
       166
        
       

     
···

       217
       171
        
                 return getTransactionPromise(transaction);

     

       218
       172
        
               })

     

       219
       173
        
               .then(

     

       220
       220
       -
                 () => deserializeBatch(chunks.join('')),

     

       174
       174
       +
                 () => data,

     

       221
       175
        
                 () => batch

     

       222
       176
        
               );

     

       223
       177
        
           },