keyv-registry 2.0.2 → 3.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +54 -22
- package/dist/cjs/constants.d.cts +3 -0
- package/dist/cjs/constants.d.ts +3 -0
- package/dist/cjs/constants.js +37 -0
- package/dist/cjs/constants.js.map +1 -0
- package/dist/cjs/index.d.cts +2 -0
- package/dist/cjs/index.d.ts +2 -0
- package/dist/cjs/index.js +8 -0
- package/dist/cjs/index.js.map +1 -1
- package/dist/cjs/loadAdapter.js +14 -2
- package/dist/cjs/loadAdapter.js.map +1 -1
- package/dist/cjs/migrate-keyv5.d.cts +18 -0
- package/dist/cjs/migrate-keyv5.d.ts +18 -0
- package/dist/cjs/migrate-keyv5.js +554 -0
- package/dist/cjs/migrate-keyv5.js.map +1 -0
- package/dist/cjs/registry.js +2 -2
- package/dist/cjs/registry.js.map +1 -1
- package/dist/cjs/types.d.cts +4 -8
- package/dist/cjs/types.d.ts +4 -8
- package/dist/cjs/utils.d.cts +14 -1
- package/dist/cjs/utils.d.ts +14 -1
- package/dist/cjs/utils.js +24 -12
- package/dist/cjs/utils.js.map +1 -1
- package/dist/cjs/worker.d.cts +7 -0
- package/dist/cjs/worker.d.ts +7 -0
- package/dist/cjs/worker.js +66 -53
- package/dist/cjs/worker.js.map +1 -1
- package/dist/esm/constants.d.ts +3 -0
- package/dist/esm/constants.js +18 -0
- package/dist/esm/constants.js.map +1 -0
- package/dist/esm/index.d.ts +2 -0
- package/dist/esm/index.js +2 -0
- package/dist/esm/index.js.map +1 -1
- package/dist/esm/loadAdapter.js +14 -2
- package/dist/esm/loadAdapter.js.map +1 -1
- package/dist/esm/migrate-keyv5.d.ts +18 -0
- package/dist/esm/migrate-keyv5.js +74 -0
- package/dist/esm/migrate-keyv5.js.map +1 -0
- package/dist/esm/registry.js +2 -2
- package/dist/esm/registry.js.map +1 -1
- package/dist/esm/types.d.ts +4 -8
- package/dist/esm/types.js.map +1 -1
- package/dist/esm/utils.d.ts +14 -1
- package/dist/esm/utils.js +21 -12
- package/dist/esm/utils.js.map +1 -1
- package/dist/esm/worker.d.ts +7 -0
- package/dist/esm/worker.js +25 -21
- package/dist/esm/worker.js.map +1 -1
- package/package.json +7 -5
|
@@ -0,0 +1,554 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", {
|
|
3
|
+
value: true
|
|
4
|
+
});
|
|
5
|
+
Object.defineProperty(exports, /**
|
|
6
|
+
* One-time move of entries keyv 5 wrote under its default `keyv` namespace to the plain keys keyv 6 reads.
|
|
7
|
+
*
|
|
8
|
+
* Works through the Keyv API only, on the instance the caller passes, so it covers every adapter that can iterate.
|
|
9
|
+
* Finds both old layouts: `keyv:<key>` with no namespace (keyv-file) and namespace `keyv` (sqlite `<key>`, redis `keyv:<key>`).
|
|
10
|
+
* Keeps the absolute expiry, skips expired entries, lets an existing plain key win, and is safe to run again.
|
|
11
|
+
*
|
|
12
|
+
* Call it at startup, before the store serves other traffic: it renames keys and switches `store.namespace` while it runs.
|
|
13
|
+
* A plain key that itself starts with `keyv:` is taken for a keyv 5 key.
|
|
14
|
+
* A store that cannot iterate (for example memcache) has nothing to find: it returns 0.
|
|
15
|
+
*
|
|
16
|
+
* Store errors: keyv hides them from the caller once any `error` listener is attached, so a temporary listener watches every read and write.
|
|
17
|
+
* If one is emitted, the old key is not deleted and the call rejects with the error as `cause`; entries already moved stay moved and a rerun repairs the rest.
|
|
18
|
+
*
|
|
19
|
+
* @returns the number of entries moved
|
|
20
|
+
*/ "default", {
|
|
21
|
+
enumerable: true,
|
|
22
|
+
get: function() {
|
|
23
|
+
return migrateKeyv5Keys;
|
|
24
|
+
}
|
|
25
|
+
});
|
|
26
|
+
var _constantsts = require("./constants.js");
|
|
27
|
+
function _array_like_to_array(arr, len) {
|
|
28
|
+
if (len == null || len > arr.length) len = arr.length;
|
|
29
|
+
for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
|
|
30
|
+
return arr2;
|
|
31
|
+
}
|
|
32
|
+
function _array_with_holes(arr) {
|
|
33
|
+
if (Array.isArray(arr)) return arr;
|
|
34
|
+
}
|
|
35
|
+
function _async_iterator(iterable) {
|
|
36
|
+
var method, async, sync, retry = 2;
|
|
37
|
+
for("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;){
|
|
38
|
+
if (async && null != (method = iterable[async])) return method.call(iterable);
|
|
39
|
+
if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
|
|
40
|
+
async = "@@asyncIterator", sync = "@@iterator";
|
|
41
|
+
}
|
|
42
|
+
throw new TypeError("Object is not async iterable");
|
|
43
|
+
}
|
|
44
|
+
function AsyncFromSyncIterator(s) {
|
|
45
|
+
function AsyncFromSyncIteratorContinuation(r) {
|
|
46
|
+
if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
|
|
47
|
+
var done = r.done;
|
|
48
|
+
return Promise.resolve(r.value).then(function(value) {
|
|
49
|
+
return {
|
|
50
|
+
value: value,
|
|
51
|
+
done: done
|
|
52
|
+
};
|
|
53
|
+
});
|
|
54
|
+
}
|
|
55
|
+
return AsyncFromSyncIterator = function(s) {
|
|
56
|
+
this.s = s, this.n = s.next;
|
|
57
|
+
}, AsyncFromSyncIterator.prototype = {
|
|
58
|
+
s: null,
|
|
59
|
+
n: null,
|
|
60
|
+
next: function() {
|
|
61
|
+
return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
|
|
62
|
+
},
|
|
63
|
+
return: function(value) {
|
|
64
|
+
var ret = this.s.return;
|
|
65
|
+
return void 0 === ret ? Promise.resolve({
|
|
66
|
+
value: value,
|
|
67
|
+
done: !0
|
|
68
|
+
}) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
|
|
69
|
+
},
|
|
70
|
+
throw: function(value) {
|
|
71
|
+
var thr = this.s.return;
|
|
72
|
+
return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
|
|
73
|
+
}
|
|
74
|
+
}, new AsyncFromSyncIterator(s);
|
|
75
|
+
}
|
|
76
|
+
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
|
|
77
|
+
try {
|
|
78
|
+
var info = gen[key](arg);
|
|
79
|
+
var value = info.value;
|
|
80
|
+
} catch (error) {
|
|
81
|
+
reject(error);
|
|
82
|
+
return;
|
|
83
|
+
}
|
|
84
|
+
if (info.done) resolve(value);
|
|
85
|
+
else Promise.resolve(value).then(_next, _throw);
|
|
86
|
+
}
|
|
87
|
+
function _async_to_generator(fn) {
|
|
88
|
+
return function() {
|
|
89
|
+
var self = this, args = arguments;
|
|
90
|
+
return new Promise(function(resolve, reject) {
|
|
91
|
+
var gen = fn.apply(self, args);
|
|
92
|
+
function _next(value) {
|
|
93
|
+
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
|
|
94
|
+
}
|
|
95
|
+
function _throw(err) {
|
|
96
|
+
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
|
|
97
|
+
}
|
|
98
|
+
_next(undefined);
|
|
99
|
+
});
|
|
100
|
+
};
|
|
101
|
+
}
|
|
102
|
+
function _iterable_to_array_limit(arr, i) {
|
|
103
|
+
var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
|
|
104
|
+
if (_i == null) return;
|
|
105
|
+
var _arr = [];
|
|
106
|
+
var _n = true;
|
|
107
|
+
var _d = false;
|
|
108
|
+
var _s, _e;
|
|
109
|
+
try {
|
|
110
|
+
for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
|
|
111
|
+
_arr.push(_s.value);
|
|
112
|
+
if (i && _arr.length === i) break;
|
|
113
|
+
}
|
|
114
|
+
} catch (err) {
|
|
115
|
+
_d = true;
|
|
116
|
+
_e = err;
|
|
117
|
+
} finally{
|
|
118
|
+
try {
|
|
119
|
+
if (!_n && _i["return"] != null) _i["return"]();
|
|
120
|
+
} finally{
|
|
121
|
+
if (_d) throw _e;
|
|
122
|
+
}
|
|
123
|
+
}
|
|
124
|
+
return _arr;
|
|
125
|
+
}
|
|
126
|
+
function _non_iterable_rest() {
|
|
127
|
+
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
128
|
+
}
|
|
129
|
+
function _sliced_to_array(arr, i) {
|
|
130
|
+
return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
|
|
131
|
+
}
|
|
132
|
+
function _ts_generator(thisArg, body) {
|
|
133
|
+
var f, y, t, _ = {
|
|
134
|
+
label: 0,
|
|
135
|
+
sent: function() {
|
|
136
|
+
if (t[0] & 1) throw t[1];
|
|
137
|
+
return t[1];
|
|
138
|
+
},
|
|
139
|
+
trys: [],
|
|
140
|
+
ops: []
|
|
141
|
+
}, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
|
|
142
|
+
return d(g, "next", {
|
|
143
|
+
value: verb(0)
|
|
144
|
+
}), d(g, "throw", {
|
|
145
|
+
value: verb(1)
|
|
146
|
+
}), d(g, "return", {
|
|
147
|
+
value: verb(2)
|
|
148
|
+
}), typeof Symbol === "function" && d(g, Symbol.iterator, {
|
|
149
|
+
value: function() {
|
|
150
|
+
return this;
|
|
151
|
+
}
|
|
152
|
+
}), g;
|
|
153
|
+
function verb(n) {
|
|
154
|
+
return function(v) {
|
|
155
|
+
return step([
|
|
156
|
+
n,
|
|
157
|
+
v
|
|
158
|
+
]);
|
|
159
|
+
};
|
|
160
|
+
}
|
|
161
|
+
function step(op) {
|
|
162
|
+
if (f) throw new TypeError("Generator is already executing.");
|
|
163
|
+
while(g && (g = 0, op[0] && (_ = 0)), _)try {
|
|
164
|
+
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
|
165
|
+
if (y = 0, t) op = [
|
|
166
|
+
op[0] & 2,
|
|
167
|
+
t.value
|
|
168
|
+
];
|
|
169
|
+
switch(op[0]){
|
|
170
|
+
case 0:
|
|
171
|
+
case 1:
|
|
172
|
+
t = op;
|
|
173
|
+
break;
|
|
174
|
+
case 4:
|
|
175
|
+
_.label++;
|
|
176
|
+
return {
|
|
177
|
+
value: op[1],
|
|
178
|
+
done: false
|
|
179
|
+
};
|
|
180
|
+
case 5:
|
|
181
|
+
_.label++;
|
|
182
|
+
y = op[1];
|
|
183
|
+
op = [
|
|
184
|
+
0
|
|
185
|
+
];
|
|
186
|
+
continue;
|
|
187
|
+
case 7:
|
|
188
|
+
op = _.ops.pop();
|
|
189
|
+
_.trys.pop();
|
|
190
|
+
continue;
|
|
191
|
+
default:
|
|
192
|
+
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
|
|
193
|
+
_ = 0;
|
|
194
|
+
continue;
|
|
195
|
+
}
|
|
196
|
+
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
|
|
197
|
+
_.label = op[1];
|
|
198
|
+
break;
|
|
199
|
+
}
|
|
200
|
+
if (op[0] === 6 && _.label < t[1]) {
|
|
201
|
+
_.label = t[1];
|
|
202
|
+
t = op;
|
|
203
|
+
break;
|
|
204
|
+
}
|
|
205
|
+
if (t && _.label < t[2]) {
|
|
206
|
+
_.label = t[2];
|
|
207
|
+
_.ops.push(op);
|
|
208
|
+
break;
|
|
209
|
+
}
|
|
210
|
+
if (t[2]) _.ops.pop();
|
|
211
|
+
_.trys.pop();
|
|
212
|
+
continue;
|
|
213
|
+
}
|
|
214
|
+
op = body.call(thisArg, _);
|
|
215
|
+
} catch (e) {
|
|
216
|
+
op = [
|
|
217
|
+
6,
|
|
218
|
+
e
|
|
219
|
+
];
|
|
220
|
+
y = 0;
|
|
221
|
+
} finally{
|
|
222
|
+
f = t = 0;
|
|
223
|
+
}
|
|
224
|
+
if (op[0] & 5) throw op[1];
|
|
225
|
+
return {
|
|
226
|
+
value: op[0] ? op[1] : void 0,
|
|
227
|
+
done: true
|
|
228
|
+
};
|
|
229
|
+
}
|
|
230
|
+
}
|
|
231
|
+
function _unsupported_iterable_to_array(o, minLen) {
|
|
232
|
+
if (!o) return;
|
|
233
|
+
if (typeof o === "string") return _array_like_to_array(o, minLen);
|
|
234
|
+
var n = Object.prototype.toString.call(o).slice(8, -1);
|
|
235
|
+
if (n === "Object" && o.constructor) n = o.constructor.name;
|
|
236
|
+
if (n === "Map" || n === "Set") return Array.from(o);
|
|
237
|
+
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
|
|
238
|
+
}
|
|
239
|
+
var PREFIX = "".concat(_constantsts.KEYV5_NAMESPACE, ":");
|
|
240
|
+
function fail(message, cause) {
|
|
241
|
+
var error = new Error(message);
|
|
242
|
+
error.cause = cause;
|
|
243
|
+
return error;
|
|
244
|
+
}
|
|
245
|
+
function migrateKeyv5Keys(store) {
|
|
246
|
+
return _async_to_generator(function() {
|
|
247
|
+
var original, errors, onError, check, legacy, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, _value1, key, err, _iteratorAbruptCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, _value2, _value3, key1, err1, moved, _iteratorNormalCompletion, _didIteratorError2, _iteratorError2, _iterator2, _step2, _step_value, namespace, oldKey, newKey, raw, exists, err2;
|
|
248
|
+
return _ts_generator(this, function(_state) {
|
|
249
|
+
switch(_state.label){
|
|
250
|
+
case 0:
|
|
251
|
+
original = store.namespace;
|
|
252
|
+
errors = [];
|
|
253
|
+
onError = function onError(err) {
|
|
254
|
+
return errors.push(err);
|
|
255
|
+
};
|
|
256
|
+
check = function check(what) {
|
|
257
|
+
var _ref;
|
|
258
|
+
var _errors_;
|
|
259
|
+
if (errors.length > 0) throw fail("migrateKeyv5Keys: ".concat(what, ": ").concat((_ref = (_errors_ = errors[0]) === null || _errors_ === void 0 ? void 0 : _errors_.message) !== null && _ref !== void 0 ? _ref : errors[0]), errors[0]);
|
|
260
|
+
};
|
|
261
|
+
store.on('error', onError);
|
|
262
|
+
_state.label = 1;
|
|
263
|
+
case 1:
|
|
264
|
+
_state.trys.push([
|
|
265
|
+
1,
|
|
266
|
+
,
|
|
267
|
+
38,
|
|
268
|
+
39
|
|
269
|
+
]);
|
|
270
|
+
legacy = [];
|
|
271
|
+
// Collect first, then change anything, so the iterators never see our own writes.
|
|
272
|
+
store.namespace = undefined;
|
|
273
|
+
_iteratorAbruptCompletion = false, _didIteratorError = false;
|
|
274
|
+
_state.label = 2;
|
|
275
|
+
case 2:
|
|
276
|
+
_state.trys.push([
|
|
277
|
+
2,
|
|
278
|
+
7,
|
|
279
|
+
8,
|
|
280
|
+
13
|
|
281
|
+
]);
|
|
282
|
+
_iterator = _async_iterator(store.iterator());
|
|
283
|
+
_state.label = 3;
|
|
284
|
+
case 3:
|
|
285
|
+
return [
|
|
286
|
+
4,
|
|
287
|
+
_iterator.next()
|
|
288
|
+
];
|
|
289
|
+
case 4:
|
|
290
|
+
if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done)) return [
|
|
291
|
+
3,
|
|
292
|
+
6
|
|
293
|
+
];
|
|
294
|
+
_value = _step.value;
|
|
295
|
+
_value1 = _sliced_to_array(_value, 1), key = _value1[0];
|
|
296
|
+
if (typeof key === 'string' && key.startsWith(PREFIX)) legacy.push({
|
|
297
|
+
namespace: undefined,
|
|
298
|
+
oldKey: key,
|
|
299
|
+
newKey: key.slice(PREFIX.length)
|
|
300
|
+
});
|
|
301
|
+
_state.label = 5;
|
|
302
|
+
case 5:
|
|
303
|
+
_iteratorAbruptCompletion = false;
|
|
304
|
+
return [
|
|
305
|
+
3,
|
|
306
|
+
3
|
|
307
|
+
];
|
|
308
|
+
case 6:
|
|
309
|
+
return [
|
|
310
|
+
3,
|
|
311
|
+
13
|
|
312
|
+
];
|
|
313
|
+
case 7:
|
|
314
|
+
err = _state.sent();
|
|
315
|
+
_didIteratorError = true;
|
|
316
|
+
_iteratorError = err;
|
|
317
|
+
return [
|
|
318
|
+
3,
|
|
319
|
+
13
|
|
320
|
+
];
|
|
321
|
+
case 8:
|
|
322
|
+
_state.trys.push([
|
|
323
|
+
8,
|
|
324
|
+
,
|
|
325
|
+
11,
|
|
326
|
+
12
|
|
327
|
+
]);
|
|
328
|
+
if (!(_iteratorAbruptCompletion && _iterator.return != null)) return [
|
|
329
|
+
3,
|
|
330
|
+
10
|
|
331
|
+
];
|
|
332
|
+
return [
|
|
333
|
+
4,
|
|
334
|
+
_iterator.return()
|
|
335
|
+
];
|
|
336
|
+
case 9:
|
|
337
|
+
_state.sent();
|
|
338
|
+
_state.label = 10;
|
|
339
|
+
case 10:
|
|
340
|
+
return [
|
|
341
|
+
3,
|
|
342
|
+
12
|
|
343
|
+
];
|
|
344
|
+
case 11:
|
|
345
|
+
if (_didIteratorError) {
|
|
346
|
+
throw _iteratorError;
|
|
347
|
+
}
|
|
348
|
+
return [
|
|
349
|
+
7
|
|
350
|
+
];
|
|
351
|
+
case 12:
|
|
352
|
+
return [
|
|
353
|
+
7
|
|
354
|
+
];
|
|
355
|
+
case 13:
|
|
356
|
+
check('listing keys failed');
|
|
357
|
+
store.namespace = _constantsts.KEYV5_NAMESPACE;
|
|
358
|
+
_iteratorAbruptCompletion1 = false, _didIteratorError1 = false;
|
|
359
|
+
_state.label = 14;
|
|
360
|
+
case 14:
|
|
361
|
+
_state.trys.push([
|
|
362
|
+
14,
|
|
363
|
+
19,
|
|
364
|
+
20,
|
|
365
|
+
25
|
|
366
|
+
]);
|
|
367
|
+
_iterator1 = _async_iterator(store.iterator());
|
|
368
|
+
_state.label = 15;
|
|
369
|
+
case 15:
|
|
370
|
+
return [
|
|
371
|
+
4,
|
|
372
|
+
_iterator1.next()
|
|
373
|
+
];
|
|
374
|
+
case 16:
|
|
375
|
+
if (!(_iteratorAbruptCompletion1 = !(_step1 = _state.sent()).done)) return [
|
|
376
|
+
3,
|
|
377
|
+
18
|
|
378
|
+
];
|
|
379
|
+
_value2 = _step1.value;
|
|
380
|
+
_value3 = _sliced_to_array(_value2, 1), key1 = _value3[0];
|
|
381
|
+
if (typeof key1 === 'string') legacy.push({
|
|
382
|
+
namespace: _constantsts.KEYV5_NAMESPACE,
|
|
383
|
+
oldKey: key1,
|
|
384
|
+
newKey: key1.startsWith(PREFIX) ? key1.slice(PREFIX.length) : key1
|
|
385
|
+
});
|
|
386
|
+
_state.label = 17;
|
|
387
|
+
case 17:
|
|
388
|
+
_iteratorAbruptCompletion1 = false;
|
|
389
|
+
return [
|
|
390
|
+
3,
|
|
391
|
+
15
|
|
392
|
+
];
|
|
393
|
+
case 18:
|
|
394
|
+
return [
|
|
395
|
+
3,
|
|
396
|
+
25
|
|
397
|
+
];
|
|
398
|
+
case 19:
|
|
399
|
+
err1 = _state.sent();
|
|
400
|
+
_didIteratorError1 = true;
|
|
401
|
+
_iteratorError1 = err1;
|
|
402
|
+
return [
|
|
403
|
+
3,
|
|
404
|
+
25
|
|
405
|
+
];
|
|
406
|
+
case 20:
|
|
407
|
+
_state.trys.push([
|
|
408
|
+
20,
|
|
409
|
+
,
|
|
410
|
+
23,
|
|
411
|
+
24
|
|
412
|
+
]);
|
|
413
|
+
if (!(_iteratorAbruptCompletion1 && _iterator1.return != null)) return [
|
|
414
|
+
3,
|
|
415
|
+
22
|
|
416
|
+
];
|
|
417
|
+
return [
|
|
418
|
+
4,
|
|
419
|
+
_iterator1.return()
|
|
420
|
+
];
|
|
421
|
+
case 21:
|
|
422
|
+
_state.sent();
|
|
423
|
+
_state.label = 22;
|
|
424
|
+
case 22:
|
|
425
|
+
return [
|
|
426
|
+
3,
|
|
427
|
+
24
|
|
428
|
+
];
|
|
429
|
+
case 23:
|
|
430
|
+
if (_didIteratorError1) {
|
|
431
|
+
throw _iteratorError1;
|
|
432
|
+
}
|
|
433
|
+
return [
|
|
434
|
+
7
|
|
435
|
+
];
|
|
436
|
+
case 24:
|
|
437
|
+
return [
|
|
438
|
+
7
|
|
439
|
+
];
|
|
440
|
+
case 25:
|
|
441
|
+
check('listing keys failed');
|
|
442
|
+
moved = 0;
|
|
443
|
+
_iteratorNormalCompletion = true, _didIteratorError2 = false, _iteratorError2 = undefined;
|
|
444
|
+
_state.label = 26;
|
|
445
|
+
case 26:
|
|
446
|
+
_state.trys.push([
|
|
447
|
+
26,
|
|
448
|
+
35,
|
|
449
|
+
36,
|
|
450
|
+
37
|
|
451
|
+
]);
|
|
452
|
+
_iterator2 = legacy[Symbol.iterator]();
|
|
453
|
+
_state.label = 27;
|
|
454
|
+
case 27:
|
|
455
|
+
if (!!(_iteratorNormalCompletion = (_step2 = _iterator2.next()).done)) return [
|
|
456
|
+
3,
|
|
457
|
+
34
|
|
458
|
+
];
|
|
459
|
+
_step_value = _step2.value, namespace = _step_value.namespace, oldKey = _step_value.oldKey, newKey = _step_value.newKey;
|
|
460
|
+
store.namespace = namespace;
|
|
461
|
+
return [
|
|
462
|
+
4,
|
|
463
|
+
store.getRaw(oldKey)
|
|
464
|
+
];
|
|
465
|
+
case 28:
|
|
466
|
+
raw = _state.sent();
|
|
467
|
+
check('reading "'.concat(oldKey, '" failed, kept it'));
|
|
468
|
+
store.namespace = undefined;
|
|
469
|
+
if (!(raw !== undefined)) return [
|
|
470
|
+
3,
|
|
471
|
+
31
|
|
472
|
+
];
|
|
473
|
+
return [
|
|
474
|
+
4,
|
|
475
|
+
store.has(newKey)
|
|
476
|
+
];
|
|
477
|
+
case 29:
|
|
478
|
+
exists = _state.sent();
|
|
479
|
+
check('checking "'.concat(newKey, '" failed, kept "').concat(oldKey, '"'));
|
|
480
|
+
if (!!exists) return [
|
|
481
|
+
3,
|
|
482
|
+
31
|
|
483
|
+
];
|
|
484
|
+
return [
|
|
485
|
+
4,
|
|
486
|
+
store.setRaw(newKey, raw)
|
|
487
|
+
];
|
|
488
|
+
case 30:
|
|
489
|
+
if (!_state.sent()) throw fail('migrateKeyv5Keys: could not write migrated key "'.concat(newKey, '", kept "').concat(oldKey, '"'), errors[0]);
|
|
490
|
+
check('writing "'.concat(newKey, '" failed, kept "').concat(oldKey, '"'));
|
|
491
|
+
moved++;
|
|
492
|
+
_state.label = 31;
|
|
493
|
+
case 31:
|
|
494
|
+
store.namespace = namespace;
|
|
495
|
+
return [
|
|
496
|
+
4,
|
|
497
|
+
store.delete(oldKey)
|
|
498
|
+
];
|
|
499
|
+
case 32:
|
|
500
|
+
_state.sent(); // after the write: a crash in between leaves both, and a rerun keeps the plain key
|
|
501
|
+
check('deleting "'.concat(oldKey, '" failed'));
|
|
502
|
+
_state.label = 33;
|
|
503
|
+
case 33:
|
|
504
|
+
_iteratorNormalCompletion = true;
|
|
505
|
+
return [
|
|
506
|
+
3,
|
|
507
|
+
27
|
|
508
|
+
];
|
|
509
|
+
case 34:
|
|
510
|
+
return [
|
|
511
|
+
3,
|
|
512
|
+
37
|
|
513
|
+
];
|
|
514
|
+
case 35:
|
|
515
|
+
err2 = _state.sent();
|
|
516
|
+
_didIteratorError2 = true;
|
|
517
|
+
_iteratorError2 = err2;
|
|
518
|
+
return [
|
|
519
|
+
3,
|
|
520
|
+
37
|
|
521
|
+
];
|
|
522
|
+
case 36:
|
|
523
|
+
try {
|
|
524
|
+
if (!_iteratorNormalCompletion && _iterator2.return != null) {
|
|
525
|
+
_iterator2.return();
|
|
526
|
+
}
|
|
527
|
+
} finally{
|
|
528
|
+
if (_didIteratorError2) {
|
|
529
|
+
throw _iteratorError2;
|
|
530
|
+
}
|
|
531
|
+
}
|
|
532
|
+
return [
|
|
533
|
+
7
|
|
534
|
+
];
|
|
535
|
+
case 37:
|
|
536
|
+
return [
|
|
537
|
+
2,
|
|
538
|
+
moved
|
|
539
|
+
];
|
|
540
|
+
case 38:
|
|
541
|
+
store.off('error', onError);
|
|
542
|
+
store.namespace = original;
|
|
543
|
+
return [
|
|
544
|
+
7
|
|
545
|
+
];
|
|
546
|
+
case 39:
|
|
547
|
+
return [
|
|
548
|
+
2
|
|
549
|
+
];
|
|
550
|
+
}
|
|
551
|
+
});
|
|
552
|
+
})();
|
|
553
|
+
}
|
|
554
|
+
/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"sources":["/Users/kevin/Dev/open-source/keyv/keyv-registry/src/migrate-keyv5.ts"],"sourcesContent":["import type { Keyv, KeyvValue } from 'keyv';\nimport { KEYV5_NAMESPACE } from './constants.ts';\n\nconst PREFIX = `${KEYV5_NAMESPACE}:`;\n\ninterface LegacyKey {\n /** Namespace the old key is read and deleted under */\n namespace: string | undefined;\n oldKey: string;\n newKey: string;\n}\n\nfunction fail(message: string, cause: unknown): Error {\n const error = new Error(message);\n (error as Error & { cause?: unknown }).cause = cause;\n return error;\n}\n\n/**\n * One-time move of entries keyv 5 wrote under its default `keyv` namespace to the plain keys keyv 6 reads.\n *\n * Works through the Keyv API only, on the instance the caller passes, so it covers every adapter that can iterate.\n * Finds both old layouts: `keyv:<key>` with no namespace (keyv-file) and namespace `keyv` (sqlite `<key>`, redis `keyv:<key>`).\n * Keeps the absolute expiry, skips expired entries, lets an existing plain key win, and is safe to run again.\n *\n * Call it at startup, before the store serves other traffic: it renames keys and switches `store.namespace` while it runs.\n * A plain key that itself starts with `keyv:` is taken for a keyv 5 key.\n * A store that cannot iterate (for example memcache) has nothing to find: it returns 0.\n *\n * Store errors: keyv hides them from the caller once any `error` listener is attached, so a temporary listener watches every read and write.\n * If one is emitted, the old key is not deleted and the call rejects with the error as `cause`; entries already moved stay moved and a rerun repairs the rest.\n *\n * @returns the number of entries moved\n */\nexport default async function migrateKeyv5Keys(store: Keyv): Promise<number> {\n const original = store.namespace;\n const errors: unknown[] = [];\n const onError = (err: unknown) => errors.push(err);\n const check = (what: string) => {\n if (errors.length > 0) throw fail(`migrateKeyv5Keys: ${what}: ${(errors[0] as Error)?.message ?? errors[0]}`, errors[0]);\n };\n store.on('error', onError);\n try {\n const legacy: LegacyKey[] = [];\n\n // Collect first, then change anything, so the iterators never see our own writes.\n store.namespace = undefined;\n for await (const [key] of store.iterator()) if (typeof key === 'string' && key.startsWith(PREFIX)) legacy.push({ namespace: undefined, oldKey: key, newKey: key.slice(PREFIX.length) });\n check('listing keys failed');\n store.namespace = KEYV5_NAMESPACE;\n for await (const [key] of store.iterator()) if (typeof key === 'string') legacy.push({ namespace: KEYV5_NAMESPACE, oldKey: key, newKey: key.startsWith(PREFIX) ? key.slice(PREFIX.length) : key });\n check('listing keys failed');\n\n let moved = 0;\n for (const { namespace, oldKey, newKey } of legacy) {\n store.namespace = namespace;\n const raw = await store.getRaw(oldKey); // undefined when expired, and when the store failed (then an error was emitted)\n check(`reading \"${oldKey}\" failed, kept it`);\n store.namespace = undefined;\n if (raw !== undefined) {\n const exists = await store.has(newKey);\n check(`checking \"${newKey}\" failed, kept \"${oldKey}\"`);\n if (!exists) {\n if (!(await store.setRaw(newKey, raw as KeyvValue<unknown>))) throw fail(`migrateKeyv5Keys: could not write migrated key \"${newKey}\", kept \"${oldKey}\"`, errors[0]);\n check(`writing \"${newKey}\" failed, kept \"${oldKey}\"`);\n moved++;\n }\n }\n store.namespace = namespace;\n await store.delete(oldKey); // after the write: a crash in between leaves both, and a rerun keeps the plain key\n check(`deleting \"${oldKey}\" failed`);\n }\n return moved;\n } finally {\n store.off('error', onError);\n store.namespace = original;\n }\n}\n"],"names":["migrateKeyv5Keys","PREFIX","KEYV5_NAMESPACE","fail","message","cause","error","Error","store","original","errors","onError","check","legacy","key","moved","namespace","oldKey","newKey","raw","exists","err","push","what","length","on","undefined","iterator","startsWith","slice","getRaw","has","setRaw","delete","off"],"mappings":"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"}
|
package/dist/cjs/registry.js
CHANGED
|
@@ -90,7 +90,7 @@ function _object_spread(target) {
|
|
|
90
90
|
mode: 'options',
|
|
91
91
|
optionsMapper: function optionsMapper(url) {
|
|
92
92
|
return {
|
|
93
|
-
uri:
|
|
93
|
+
uri: "sqlite://".concat((0, _utilsts.resolveFilePath)(url))
|
|
94
94
|
};
|
|
95
95
|
}
|
|
96
96
|
},
|
|
@@ -144,7 +144,7 @@ function _object_spread(target) {
|
|
|
144
144
|
package: 'keyv-duckdb',
|
|
145
145
|
optionsMapper: function optionsMapper(url) {
|
|
146
146
|
return {
|
|
147
|
-
|
|
147
|
+
path: (0, _utilsts.resolveFilePath)(url)
|
|
148
148
|
};
|
|
149
149
|
}
|
|
150
150
|
}
|
package/dist/cjs/registry.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"sources":["/Users/kevin/Dev/
|
|
1
|
+
{"version":3,"sources":["/Users/kevin/Dev/open-source/keyv/keyv-registry/src/registry.ts"],"sourcesContent":["import type { AdapterConfig } from './types.ts';\nimport { resolveFilePath } from './utils.ts';\n\n/**\n * Protocol registry mapping URI protocols to adapter configurations\n */\nconst PROTOCOL_REGISTRY: Record<string, AdapterConfig> = {\n // Official @keyv adapters\n 'redis:': { package: '@keyv/redis', mode: 'string' },\n 'rediss:': { package: '@keyv/redis', mode: 'string' },\n 'postgresql:': { package: '@keyv/postgres', mode: 'options', optionsMapper: (url) => ({ uri: url.toString() }) },\n 'postgres:': { package: '@keyv/postgres', mode: 'options', optionsMapper: (url) => ({ uri: url.toString() }) },\n 'mysql:': { package: '@keyv/mysql', mode: 'options', optionsMapper: (url) => ({ uri: url.toString() }) },\n 'sqlite:': { package: '@keyv/sqlite', mode: 'options', optionsMapper: (url) => ({ uri: `sqlite://${resolveFilePath(url)}` }) },\n 'mongodb:': { package: '@keyv/mongo', mode: 'options', optionsMapper: (url) => ({ url: url.toString() }) },\n 'mongodb+srv:': { package: '@keyv/mongo', mode: 'options', optionsMapper: (url) => ({ url: url.toString() }) },\n 'memcache:': { package: '@keyv/memcache', mode: 'string' },\n 'etcd:': { package: '@keyv/etcd', mode: 'options', optionsMapper: (url) => ({ url: url.toString() }) },\n\n // Third-party adapters\n 'file:': {\n package: 'keyv-file',\n exportName: 'KeyvFile',\n optionsMapper: (url: URL) => ({ filename: resolveFilePath(url) }),\n },\n\n // Built-in (no package needed)\n 'memory:': { package: null },\n\n // Future/custom adapters\n 'duckdb:': {\n package: 'keyv-duckdb',\n optionsMapper: (url: URL) => ({ path: resolveFilePath(url) }),\n },\n};\n\n/**\n * Register or override a protocol adapter\n */\nexport function registerAdapter(protocol: string, config: AdapterConfig): void {\n const normalizedProtocol = protocol.endsWith(':') ? protocol : `${protocol}:`;\n PROTOCOL_REGISTRY[normalizedProtocol] = config;\n}\n\n/**\n * Get the current registry (read-only copy)\n */\nexport function getRegistry(): Readonly<Record<string, AdapterConfig>> {\n return { ...PROTOCOL_REGISTRY };\n}\n\n/**\n * Get adapter config for a protocol\n */\nexport function getAdapterConfig(protocol: string): AdapterConfig | undefined {\n return PROTOCOL_REGISTRY[protocol];\n}\n"],"names":["getAdapterConfig","getRegistry","registerAdapter","PROTOCOL_REGISTRY","package","mode","optionsMapper","url","uri","toString","resolveFilePath","exportName","filename","path","protocol","config","normalizedProtocol","endsWith"],"mappings":";;;;;;;;;;;QAsDgBA;eAAAA;;QAPAC;eAAAA;;QARAC;eAAAA;;;uBAtCgB;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhC;;CAEC,GACD,IAAMC,oBAAmD;IACvD,0BAA0B;IAC1B,UAAU;QAAEC,SAAS;QAAeC,MAAM;IAAS;IACnD,WAAW;QAAED,SAAS;QAAeC,MAAM;IAAS;IACpD,eAAe;QAAED,SAAS;QAAkBC,MAAM;QAAWC,eAAe,SAAfA,cAAgBC;mBAAS;gBAAEC,KAAKD,IAAIE,QAAQ;YAAG;;IAAG;IAC/G,aAAa;QAAEL,SAAS;QAAkBC,MAAM;QAAWC,eAAe,SAAfA,cAAgBC;mBAAS;gBAAEC,KAAKD,IAAIE,QAAQ;YAAG;;IAAG;IAC7G,UAAU;QAAEL,SAAS;QAAeC,MAAM;QAAWC,eAAe,SAAfA,cAAgBC;mBAAS;gBAAEC,KAAKD,IAAIE,QAAQ;YAAG;;IAAG;IACvG,WAAW;QAAEL,SAAS;QAAgBC,MAAM;QAAWC,eAAe,SAAfA,cAAgBC;mBAAS;gBAAEC,KAAK,AAAC,YAAgC,OAArBE,IAAAA,wBAAe,EAACH;YAAO;;IAAG;IAC7H,YAAY;QAAEH,SAAS;QAAeC,MAAM;QAAWC,eAAe,SAAfA,cAAgBC;mBAAS;gBAAEA,KAAKA,IAAIE,QAAQ;YAAG;;IAAG;IACzG,gBAAgB;QAAEL,SAAS;QAAeC,MAAM;QAAWC,eAAe,SAAfA,cAAgBC;mBAAS;gBAAEA,KAAKA,IAAIE,QAAQ;YAAG;;IAAG;IAC7G,aAAa;QAAEL,SAAS;QAAkBC,MAAM;IAAS;IACzD,SAAS;QAAED,SAAS;QAAcC,MAAM;QAAWC,eAAe,SAAfA,cAAgBC;mBAAS;gBAAEA,KAAKA,IAAIE,QAAQ;YAAG;;IAAG;IAErG,uBAAuB;IACvB,SAAS;QACPL,SAAS;QACTO,YAAY;QACZL,eAAe,SAAfA,cAAgBC;mBAAc;gBAAEK,UAAUF,IAAAA,wBAAe,EAACH;YAAK;;IACjE;IAEA,+BAA+B;IAC/B,WAAW;QAAEH,SAAS;IAAK;IAE3B,yBAAyB;IACzB,WAAW;QACTA,SAAS;QACTE,eAAe,SAAfA,cAAgBC;mBAAc;gBAAEM,MAAMH,IAAAA,wBAAe,EAACH;YAAK;;IAC7D;AACF;AAKO,SAASL,gBAAgBY,QAAgB,EAAEC,MAAqB;IACrE,IAAMC,qBAAqBF,SAASG,QAAQ,CAAC,OAAOH,WAAW,AAAC,GAAW,OAATA,UAAS;IAC3EX,iBAAiB,CAACa,mBAAmB,GAAGD;AAC1C;AAKO,SAASd;IACd,OAAO,mBAAKE;AACd;AAKO,SAASH,iBAAiBc,QAAgB;IAC/C,OAAOX,iBAAiB,CAACW,SAAS;AACpC"}
|
package/dist/cjs/types.d.cts
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import type Keyv from 'keyv';
|
|
1
|
+
import type { Keyv, KeyvOptions } from 'keyv';
|
|
2
2
|
/**
|
|
3
3
|
* Configuration for a protocol adapter
|
|
4
4
|
*/
|
|
@@ -15,14 +15,10 @@ export interface AdapterConfig {
|
|
|
15
15
|
/**
|
|
16
16
|
* Options for createStore
|
|
17
17
|
*/
|
|
18
|
-
export interface CreateStoreOptions {
|
|
18
|
+
export interface CreateStoreOptions extends Partial<KeyvOptions> {
|
|
19
19
|
/** Pre-instantiated adapter (bypasses URI loading) */
|
|
20
|
-
store?:
|
|
21
|
-
/**
|
|
22
|
-
namespace?: string;
|
|
23
|
-
/** Default TTL in milliseconds */
|
|
24
|
-
ttl?: number;
|
|
25
|
-
/** Additional Keyv options */
|
|
20
|
+
store?: KeyvOptions['store'];
|
|
21
|
+
/** Options passed through to the adapter constructor */
|
|
26
22
|
[key: string]: unknown;
|
|
27
23
|
}
|
|
28
24
|
/**
|
package/dist/cjs/types.d.ts
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import type Keyv from 'keyv';
|
|
1
|
+
import type { Keyv, KeyvOptions } from 'keyv';
|
|
2
2
|
/**
|
|
3
3
|
* Configuration for a protocol adapter
|
|
4
4
|
*/
|
|
@@ -15,14 +15,10 @@ export interface AdapterConfig {
|
|
|
15
15
|
/**
|
|
16
16
|
* Options for createStore
|
|
17
17
|
*/
|
|
18
|
-
export interface CreateStoreOptions {
|
|
18
|
+
export interface CreateStoreOptions extends Partial<KeyvOptions> {
|
|
19
19
|
/** Pre-instantiated adapter (bypasses URI loading) */
|
|
20
|
-
store?:
|
|
21
|
-
/**
|
|
22
|
-
namespace?: string;
|
|
23
|
-
/** Default TTL in milliseconds */
|
|
24
|
-
ttl?: number;
|
|
25
|
-
/** Additional Keyv options */
|
|
20
|
+
store?: KeyvOptions['store'];
|
|
21
|
+
/** Options passed through to the adapter constructor */
|
|
26
22
|
[key: string]: unknown;
|
|
27
23
|
}
|
|
28
24
|
/**
|
package/dist/cjs/utils.d.cts
CHANGED
|
@@ -1,5 +1,18 @@
|
|
|
1
1
|
/**
|
|
2
|
-
*
|
|
2
|
+
* Parse a store URI, keeping a Windows drive letter written after `//` in the path
|
|
3
|
+
*/
|
|
4
|
+
export declare function parseUri(uri: string): URL;
|
|
5
|
+
export interface ToFilePathOptions {
|
|
6
|
+
windows?: boolean;
|
|
7
|
+
homedir?: string;
|
|
8
|
+
cwd?: string;
|
|
9
|
+
}
|
|
10
|
+
/**
|
|
11
|
+
* Convert a file-backed store URL to a native path, handling ~ and . prefixes (no filesystem access)
|
|
12
|
+
*/
|
|
13
|
+
export declare function toFilePath(url: URL, options?: ToFilePathOptions): string;
|
|
14
|
+
/**
|
|
15
|
+
* Resolve file path from URL and create its parent directory
|
|
3
16
|
*/
|
|
4
17
|
export declare function resolveFilePath(url: URL): string;
|
|
5
18
|
/**
|