···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
---

     

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

     

       
3
       
+
       
---

     

       
4
       
+
       


     

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

     

···

       
78
       
 
       
    req.result.createObjectStore(METADATA_STORE_NAME);

     

       
79
       
 
       
  };

     

       
80
       
 
       


     

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

     

       
82
       
-
       


     

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

     

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

     

       
85
       
-
       


     

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

     

       
87
       
-
       
    let data = '';

     

       
88
       
-
       
    for (const key in batch) {

     

       
89
       
-
       
      const value = batch[key];

     

       
90
       
-
       
      data += serializeEntry(key);

     

       
91
       
-
       
      data += ':';

     

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

     

       
93
       
-
       
      data += ':';

     

       
94
       
-
       
    }

     

       
95
       
-
       


     

       
96
       
-
       
    return data;

     

       
97
       
-
       
  };

     

       
98
       
-
       


     

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

     

       
100
       
-
       
    const data = {};

     

       
101
       
-
       
    let char = '';

     

       
102
       
-
       
    let key = '';

     

       
103
       
-
       
    let entry = '';

     

       
104
       
-
       
    let mode = 0;

     

       
105
       
-
       
    let index = 0;

     

       
106
       
-
       
    while (index < input.length) {

     

       
107
       
-
       
      entry = '';

     

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

     

       
109
       
-
       
        entry += char;

     

       
110
       
-
       
      }

     

       
111
       
-
       


     

       
112
       
-
       
      if (mode) {

     

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

     

       
114
       
-
       
        mode = 0;

     

       
115
       
-
       
      } else {

     

       
116
       
-
       
        key = deserializeEntry(entry);

     

       
117
       
-
       
        mode = 1;

     

       
118
       
-
       
      }

     

       
119
       
-
       
    }

     

       
120
       
-
       


     

       
121
       
-
       
    return data;

     

       
122
       
-
       
  };

     

       
123
       
-
       


     

       
124
       
 
       
  return {

     

       
125
       
 
       
    clear() {

     

       
126
       
 
       
      return database$.then(database => {

     
···

       
175
       
 
       
            database

     

       
176
       
 
       
              .transaction(ENTRIES_STORE_NAME, 'readwrite')

     

       
177
       
 
       
              .objectStore(ENTRIES_STORE_NAME)

     

       
178
       
-
       
              .put(serializeBatch(), timestamp)

     

       
179
       
 
       
          );

     

       
180
       
 
       
        })

     

       
181
       
 
       
        .then(toUndefined, toUndefined);

     

       
182
       
 
       
    },

     

       
183
       
 
       


     

       
184
       
 
       
    readData(): Promise<SerializedEntries> {

     

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

     

       
186
       
 
       
      return database$

     

       
187
       
 
       
        .then(database => {

     

       
188
       
 
       
          const transaction = database.transaction(

     
···

       
200
       
 
       
                store.delete(key);

     

       
201
       
 
       
              } else {

     

       
202
       
 
       
                const request = store.get(key);

     

       
203
       
-
       
                const index = chunks.length;

     

       
204
       
-
       
                chunks.push('');

     

       
205
       
 
       
                request.onsuccess = () => {

     

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

     

       
207
       
-
       
                  if (key === timestamp)

     

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

     

       
209
       
-
       
                  chunks[index] = result;

     

       
210
       
 
       
                };

     

       
211
       
 
       
              }

     

       
212
       
 
       


     
···

       
217
       
 
       
          return getTransactionPromise(transaction);

     

       
218
       
 
       
        })

     

       
219
       
 
       
        .then(

     

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

     

       
221
       
 
       
          () => batch

     

       
222
       
 
       
        );

     

       
223
       
 
       
    },

     

···

       
78
       
 
       
    req.result.createObjectStore(METADATA_STORE_NAME);

     

       
79
       
 
       
  };

     

       
80
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
81
       
 
       
  return {

     

       
82
       
 
       
    clear() {

     

       
83
       
 
       
      return database$.then(database => {

     
···

       
132
       
 
       
            database

     

       
133
       
 
       
              .transaction(ENTRIES_STORE_NAME, 'readwrite')

     

       
134
       
 
       
              .objectStore(ENTRIES_STORE_NAME)

     

       
135
       
+
       
              .put(batch, timestamp)

     

       
136
       
 
       
          );

     

       
137
       
 
       
        })

     

       
138
       
 
       
        .then(toUndefined, toUndefined);

     

       
139
       
 
       
    },

     

       
140
       
 
       


     

       
141
       
 
       
    readData(): Promise<SerializedEntries> {

     

       
142
       
+
       
      const data: SerializedEntries = {};

     

       
143
       
 
       
      return database$

     

       
144
       
 
       
        .then(database => {

     

       
145
       
 
       
          const transaction = database.transaction(

     
···

       
157
       
 
       
                store.delete(key);

     

       
158
       
 
       
              } else {

     

       
159
       
 
       
                const request = store.get(key);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
160
       
 
       
                request.onsuccess = () => {

     

       
161
       
+
       
                  const result = request.result;

     

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

     

       
163
       
+
       
                  Object.assign(data, result);

     

       
0
       
 
       

     

       
164
       
 
       
                };

     

       
165
       
 
       
              }

     

       
166
       
 
       


     
···

       
171
       
 
       
          return getTransactionPromise(transaction);

     

       
172
       
 
       
        })

     

       
173
       
 
       
        .then(

     

       
174
       
+
       
          () => data,

     

       
175
       
 
       
          () => batch

     

       
176
       
 
       
        );

     

       
177
       
 
       
    },