@tinyshed/tinystore 0.1.0-rc.1
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/LICENSE +202 -0
- package/README.md +262 -0
- package/bin/tinystore.js +50 -0
- package/dist/background.d.ts +30 -0
- package/dist/background.js +93 -0
- package/dist/blobs.d.ts +98 -0
- package/dist/blobs.js +299 -0
- package/dist/cancel.d.ts +14 -0
- package/dist/cancel.js +22 -0
- package/dist/clock.d.ts +21 -0
- package/dist/clock.js +35 -0
- package/dist/config.d.ts +60 -0
- package/dist/config.js +417 -0
- package/dist/connection.d.ts +78 -0
- package/dist/connection.js +405 -0
- package/dist/console.d.ts +48 -0
- package/dist/console.js +195 -0
- package/dist/errors.d.ts +103 -0
- package/dist/errors.js +158 -0
- package/dist/handles.d.ts +28 -0
- package/dist/handles.js +37 -0
- package/dist/index.d.ts +21 -0
- package/dist/index.js +7 -0
- package/dist/jobs.d.ts +304 -0
- package/dist/jobs.js +684 -0
- package/dist/kv.d.ts +283 -0
- package/dist/kv.js +815 -0
- package/dist/limiter.d.ts +45 -0
- package/dist/limiter.js +68 -0
- package/dist/logger.d.ts +96 -0
- package/dist/logger.js +243 -0
- package/dist/metrics.d.ts +249 -0
- package/dist/metrics.js +610 -0
- package/dist/once.d.ts +31 -0
- package/dist/once.js +116 -0
- package/dist/quota.d.ts +44 -0
- package/dist/quota.js +98 -0
- package/dist/records.d.ts +182 -0
- package/dist/records.js +346 -0
- package/dist/runtime/bun.d.ts +2 -0
- package/dist/runtime/bun.js +164 -0
- package/dist/runtime/node.d.ts +2 -0
- package/dist/runtime/node.js +157 -0
- package/dist/runtime/shared.d.ts +25 -0
- package/dist/runtime/shared.js +45 -0
- package/dist/runtime.d.ts +48 -0
- package/dist/runtime.js +4 -0
- package/dist/schema.d.ts +39 -0
- package/dist/schema.js +21 -0
- package/dist/session.d.ts +120 -0
- package/dist/session.js +546 -0
- package/dist/sql.d.ts +121 -0
- package/dist/sql.js +342 -0
- package/dist/store.d.ts +103 -0
- package/dist/store.js +153 -0
- package/dist/time.d.ts +35 -0
- package/dist/time.js +44 -0
- package/dist/trace.d.ts +18 -0
- package/dist/trace.js +22 -0
- package/dist/wire/codec.d.ts +90 -0
- package/dist/wire/codec.js +383 -0
- package/dist/wire/frame.d.ts +41 -0
- package/dist/wire/frame.js +102 -0
- package/dist/wire/messages.d.ts +1403 -0
- package/dist/wire/messages.js +472 -0
- package/dist/wire/msgpack.d.ts +93 -0
- package/dist/wire/msgpack.js +680 -0
- package/package.json +40 -0
- package/src/background.ts +108 -0
- package/src/blobs.ts +437 -0
- package/src/cancel.ts +26 -0
- package/src/clock.ts +45 -0
- package/src/config.ts +501 -0
- package/src/connection.ts +512 -0
- package/src/console.ts +228 -0
- package/src/errors.ts +211 -0
- package/src/handles.ts +68 -0
- package/src/index.ts +92 -0
- package/src/jobs.ts +963 -0
- package/src/kv.ts +1093 -0
- package/src/limiter.ts +99 -0
- package/src/logger.ts +326 -0
- package/src/metrics.ts +896 -0
- package/src/once.ts +142 -0
- package/src/quota.ts +137 -0
- package/src/records.ts +537 -0
- package/src/runtime/bun.ts +190 -0
- package/src/runtime/node.ts +177 -0
- package/src/runtime/shared.ts +61 -0
- package/src/runtime.ts +57 -0
- package/src/schema.ts +69 -0
- package/src/session.ts +665 -0
- package/src/sql.ts +478 -0
- package/src/store.ts +219 -0
- package/src/time.ts +87 -0
- package/src/trace.ts +32 -0
- package/src/wire/codec.ts +445 -0
- package/src/wire/frame.ts +139 -0
- package/src/wire/messages.ts +562 -0
- package/src/wire/msgpack.ts +712 -0
|
@@ -0,0 +1,472 @@
|
|
|
1
|
+
// Every message of docs/wire.md, by the names its tables give each field.
|
|
2
|
+
// messages.json holds a vector of each, which test/wire.test.ts reads through
|
|
3
|
+
// these declarations.
|
|
4
|
+
import { bin, bool, floats, int, int64, ints, key, kvValue, list, message, names, nullable, sqlValue, str, text, uint, } from './codec.js';
|
|
5
|
+
export const methods = {
|
|
6
|
+
'server.stop': 0x0001,
|
|
7
|
+
'server.clock': 0x0002,
|
|
8
|
+
'server.backup': 0x0003,
|
|
9
|
+
'kv.open': 0x0101,
|
|
10
|
+
'kv.get': 0x0102,
|
|
11
|
+
'kv.has': 0x0103,
|
|
12
|
+
'kv.set': 0x0104,
|
|
13
|
+
'kv.delete': 0x0105,
|
|
14
|
+
'kv.take': 0x0106,
|
|
15
|
+
'kv.touch': 0x0107,
|
|
16
|
+
'kv.add': 0x0108,
|
|
17
|
+
'kv.max': 0x0109,
|
|
18
|
+
'kv.clear': 0x010a,
|
|
19
|
+
'kv.batch': 0x010b,
|
|
20
|
+
'kv.view': 0x010c,
|
|
21
|
+
'kv.scan': 0x010d,
|
|
22
|
+
'kv.allow': 0x010e,
|
|
23
|
+
'kv.configure': 0x010f,
|
|
24
|
+
'kv.watch': 0x0110,
|
|
25
|
+
'kv.run': 0x0111,
|
|
26
|
+
'kv.usage': 0x0112,
|
|
27
|
+
'kv.refund': 0x0113,
|
|
28
|
+
'jobs.open': 0x0201,
|
|
29
|
+
'jobs.enqueue': 0x0202,
|
|
30
|
+
'jobs.update': 0x0203,
|
|
31
|
+
'jobs.cancel': 0x0204,
|
|
32
|
+
'jobs.get': 0x0205,
|
|
33
|
+
'jobs.claim': 0x0206,
|
|
34
|
+
'jobs.settle': 0x0207,
|
|
35
|
+
'jobs.scan': 0x0208,
|
|
36
|
+
'jobs.work': 0x0209,
|
|
37
|
+
'jobs.watch': 0x020a,
|
|
38
|
+
'jobs.step': 0x020b,
|
|
39
|
+
'jobs.keep': 0x020c,
|
|
40
|
+
'blobs.open': 0x0301,
|
|
41
|
+
'blobs.stat': 0x0302,
|
|
42
|
+
'blobs.delete': 0x0303,
|
|
43
|
+
'blobs.copy': 0x0304,
|
|
44
|
+
'blobs.move': 0x0305,
|
|
45
|
+
'blobs.usage': 0x0306,
|
|
46
|
+
'blobs.clear': 0x0307,
|
|
47
|
+
'blobs.scan': 0x0308,
|
|
48
|
+
'blobs.put': 0x0309,
|
|
49
|
+
'blobs.get': 0x030a,
|
|
50
|
+
'sql.open': 0x0401,
|
|
51
|
+
'sql.exec': 0x0402,
|
|
52
|
+
'sql.query': 0x0403,
|
|
53
|
+
'sql.batch': 0x0404,
|
|
54
|
+
'records.append': 0x0501,
|
|
55
|
+
'records.read': 0x0502,
|
|
56
|
+
'records.follow': 0x0503,
|
|
57
|
+
'records.lines': 0x0504,
|
|
58
|
+
'records.damaged': 0x0505,
|
|
59
|
+
'records.drop': 0x0506,
|
|
60
|
+
'metrics.ingest': 0x0601,
|
|
61
|
+
'metrics.read': 0x0602,
|
|
62
|
+
'metrics.aggregate': 0x0603,
|
|
63
|
+
'metrics.drop': 0x0604,
|
|
64
|
+
'metrics.explain': 0x0605,
|
|
65
|
+
};
|
|
66
|
+
export const Hello = message('hello', {
|
|
67
|
+
protocol: [1, uint],
|
|
68
|
+
client: [2, str],
|
|
69
|
+
token: [3, str],
|
|
70
|
+
maxBody: [4, uint],
|
|
71
|
+
streamCredit: [5, uint],
|
|
72
|
+
challenge: [6, bin],
|
|
73
|
+
});
|
|
74
|
+
export const Welcome = message('welcome', {
|
|
75
|
+
protocol: [1, uint],
|
|
76
|
+
server: [2, str],
|
|
77
|
+
instance: [3, bin],
|
|
78
|
+
capability: [4, str],
|
|
79
|
+
maxBody: [5, uint],
|
|
80
|
+
inFlight: [6, uint],
|
|
81
|
+
connectionCredit: [7, uint],
|
|
82
|
+
streamCredit: [8, uint],
|
|
83
|
+
engines: [9, list(str)],
|
|
84
|
+
now: [10, int],
|
|
85
|
+
proof: [11, bin],
|
|
86
|
+
});
|
|
87
|
+
export const GoAway = message('goaway', { code: [1, str], message: [2, str] });
|
|
88
|
+
export const Failure = message('error', {
|
|
89
|
+
code: [1, str],
|
|
90
|
+
message: [2, str],
|
|
91
|
+
what: [3, names(text)],
|
|
92
|
+
});
|
|
93
|
+
export const Handle = message('handle', { handle: [1, uint] });
|
|
94
|
+
export const Empty = message('empty', {});
|
|
95
|
+
export const Clock = message('clock', { at: [1, int], advance: [2, uint] });
|
|
96
|
+
export const KvWindow = message('kv.window', { name: [1, str], limit: [2, uint], per: [3, uint] });
|
|
97
|
+
export const KvBucket = message('kv.bucket', {
|
|
98
|
+
name: [1, str],
|
|
99
|
+
counters: [2, bool],
|
|
100
|
+
defaultTtl: [3, uint],
|
|
101
|
+
sliding: [4, uint],
|
|
102
|
+
loseAtMost: [5, uint],
|
|
103
|
+
config: [6, bool],
|
|
104
|
+
rate: [7, uint],
|
|
105
|
+
per: [8, uint],
|
|
106
|
+
burst: [9, uint],
|
|
107
|
+
once: [10, bool],
|
|
108
|
+
windows: [11, list(KvWindow)],
|
|
109
|
+
});
|
|
110
|
+
const kvCall = {
|
|
111
|
+
handle: [1, uint],
|
|
112
|
+
owners: [2, list(key)],
|
|
113
|
+
key: [3, key],
|
|
114
|
+
value: [4, kvValue],
|
|
115
|
+
ttl: [5, uint],
|
|
116
|
+
expireAt: [6, int],
|
|
117
|
+
ifVersion: [7, bin],
|
|
118
|
+
ifAbsent: [8, bool],
|
|
119
|
+
n: [9, int64],
|
|
120
|
+
after: [10, key],
|
|
121
|
+
limit: [11, uint],
|
|
122
|
+
};
|
|
123
|
+
export const KvCall = message('kv.call', kvCall);
|
|
124
|
+
export const KvOperation = message('kv.operation', { method: [0, uint], ...kvCall });
|
|
125
|
+
export const KvCalls = message('kv.calls', { calls: [1, list(KvOperation)] });
|
|
126
|
+
export const KvEntry = message('kv.entry', {
|
|
127
|
+
found: [1, bool],
|
|
128
|
+
value: [2, kvValue],
|
|
129
|
+
version: [3, bin],
|
|
130
|
+
expires: [4, int],
|
|
131
|
+
key: [5, key],
|
|
132
|
+
});
|
|
133
|
+
export const KvResults = message('kv.results', { entries: [1, list(KvEntry)] });
|
|
134
|
+
export const KvPage = message('kv.page', { more: [1, bool], after: [2, key] });
|
|
135
|
+
export const KvWindowUsage = message('kv.window usage', {
|
|
136
|
+
name: [1, str],
|
|
137
|
+
used: [2, uint],
|
|
138
|
+
limit: [3, uint],
|
|
139
|
+
left: [4, uint],
|
|
140
|
+
resetAt: [5, int],
|
|
141
|
+
});
|
|
142
|
+
export const KvAllowance = message('kv.allowance', {
|
|
143
|
+
ok: [1, bool],
|
|
144
|
+
left: [2, uint],
|
|
145
|
+
retryAfter: [3, uint],
|
|
146
|
+
windows: [4, list(KvWindowUsage)],
|
|
147
|
+
});
|
|
148
|
+
export const KvConfigure = message('kv.configure', {
|
|
149
|
+
handle: [1, uint],
|
|
150
|
+
set: [2, list(str)],
|
|
151
|
+
reset: [3, list(str)],
|
|
152
|
+
});
|
|
153
|
+
export const KvKept = message('kv.kept', { changes: [1, uint], fields: [2, list(str)] });
|
|
154
|
+
export const JobsRepeat = message('jobs.repeat', {
|
|
155
|
+
cron: [1, str],
|
|
156
|
+
zone: [2, str],
|
|
157
|
+
every: [3, uint],
|
|
158
|
+
});
|
|
159
|
+
export const JobsQueue = message('jobs.queue', {
|
|
160
|
+
name: [1, str],
|
|
161
|
+
lease: [2, uint],
|
|
162
|
+
maxAttempts: [3, uint],
|
|
163
|
+
backoffFirst: [4, uint],
|
|
164
|
+
backoffMost: [5, uint],
|
|
165
|
+
maxWaiting: [6, uint],
|
|
166
|
+
keepFailed: [7, uint],
|
|
167
|
+
keepDone: [8, uint],
|
|
168
|
+
schedule: [9, JobsRepeat],
|
|
169
|
+
maxRunning: [10, uint],
|
|
170
|
+
in: [11, str],
|
|
171
|
+
});
|
|
172
|
+
const jobsJob = {
|
|
173
|
+
value: [1, str],
|
|
174
|
+
key: [2, str],
|
|
175
|
+
at: [3, int],
|
|
176
|
+
after: [4, uint],
|
|
177
|
+
repeat: [5, JobsRepeat],
|
|
178
|
+
};
|
|
179
|
+
export const JobsJob = message('jobs.job', jobsJob);
|
|
180
|
+
export const JobsBatch = message('jobs.batch', { handle: [1, uint], jobs: [2, list(JobsJob)] });
|
|
181
|
+
export const JobsChange = message('jobs.change', { ...jobsJob, handle: [6, uint] });
|
|
182
|
+
export const JobsKey = message('jobs.key', { handle: [1, uint], key: [2, str] });
|
|
183
|
+
export const JobsAnswer = message('jobs.answer', {
|
|
184
|
+
job: [1, uint],
|
|
185
|
+
name: [2, str],
|
|
186
|
+
answer: [3, str],
|
|
187
|
+
});
|
|
188
|
+
export const JobsKept = message('jobs.kept', { found: [1, bool], answer: [2, str] });
|
|
189
|
+
export const JobsEntry = message('jobs.entry', {
|
|
190
|
+
found: [1, bool],
|
|
191
|
+
key: [2, str],
|
|
192
|
+
value: [3, str],
|
|
193
|
+
at: [4, int],
|
|
194
|
+
attempt: [5, uint],
|
|
195
|
+
state: [6, uint],
|
|
196
|
+
err: [7, str],
|
|
197
|
+
repeat: [8, str],
|
|
198
|
+
ahead: [9, uint],
|
|
199
|
+
progress: [10, str],
|
|
200
|
+
ran: [11, int],
|
|
201
|
+
took: [12, uint],
|
|
202
|
+
});
|
|
203
|
+
export const JobsLease = message('jobs.lease', { handle: [1, uint], lease: [2, uint] });
|
|
204
|
+
export const JobsHeld = message('jobs.held', {
|
|
205
|
+
found: [1, bool],
|
|
206
|
+
job: [2, uint],
|
|
207
|
+
key: [3, str],
|
|
208
|
+
value: [4, str],
|
|
209
|
+
at: [5, int],
|
|
210
|
+
attempt: [6, uint],
|
|
211
|
+
cancelled: [7, bool],
|
|
212
|
+
});
|
|
213
|
+
export const JobsOutcome = message('jobs.outcome', {
|
|
214
|
+
job: [1, uint],
|
|
215
|
+
how: [2, uint],
|
|
216
|
+
err: [3, str],
|
|
217
|
+
at: [4, int],
|
|
218
|
+
after: [5, uint],
|
|
219
|
+
progress: [6, str],
|
|
220
|
+
});
|
|
221
|
+
export const JobsOutcomes = message('jobs.outcomes', { outcomes: [1, list(JobsOutcome)] });
|
|
222
|
+
export const JobsSettled = message('jobs.settled', { settled: [1, list(nullable(Failure))] });
|
|
223
|
+
export const JobsQuery = message('jobs.query', {
|
|
224
|
+
handle: [1, uint],
|
|
225
|
+
prefix: [2, str],
|
|
226
|
+
state: [3, uint],
|
|
227
|
+
after: [4, str],
|
|
228
|
+
limit: [5, uint],
|
|
229
|
+
});
|
|
230
|
+
export const JobsPage = message('jobs.page', { more: [1, bool], after: [2, str] });
|
|
231
|
+
export const JobsWorkers = message('jobs.workers', {
|
|
232
|
+
handle: [1, uint],
|
|
233
|
+
workers: [2, uint],
|
|
234
|
+
timeout: [3, uint],
|
|
235
|
+
untilIdle: [4, bool],
|
|
236
|
+
cancels: [5, bool],
|
|
237
|
+
});
|
|
238
|
+
export const BlobsBucket = message('blobs.bucket', {
|
|
239
|
+
name: [1, str],
|
|
240
|
+
defaultTtl: [2, uint],
|
|
241
|
+
maxSize: [3, uint],
|
|
242
|
+
});
|
|
243
|
+
export const BlobsCall = message('blobs.call', {
|
|
244
|
+
handle: [1, uint],
|
|
245
|
+
owners: [2, list(key)],
|
|
246
|
+
key: [3, str],
|
|
247
|
+
to: [4, str],
|
|
248
|
+
contentType: [5, str],
|
|
249
|
+
meta: [6, names(text)],
|
|
250
|
+
ttl: [7, uint],
|
|
251
|
+
expireAt: [8, int],
|
|
252
|
+
size: [9, uint],
|
|
253
|
+
ifMatch: [10, str],
|
|
254
|
+
ifNoneMatch: [11, bool],
|
|
255
|
+
prefix: [12, str],
|
|
256
|
+
after: [13, str],
|
|
257
|
+
limit: [14, uint],
|
|
258
|
+
offset: [15, uint],
|
|
259
|
+
length: [16, uint],
|
|
260
|
+
});
|
|
261
|
+
export const BlobsObject = message('blobs.object', {
|
|
262
|
+
found: [1, bool],
|
|
263
|
+
key: [2, str],
|
|
264
|
+
size: [3, uint],
|
|
265
|
+
etag: [4, str],
|
|
266
|
+
contentType: [5, str],
|
|
267
|
+
modified: [6, int],
|
|
268
|
+
expires: [7, int],
|
|
269
|
+
meta: [8, names(text)],
|
|
270
|
+
});
|
|
271
|
+
export const BlobsTotal = message('blobs.total', { objects: [1, int], bytes: [2, int] });
|
|
272
|
+
export const BlobsPage = message('blobs.page', { more: [1, bool], after: [2, str] });
|
|
273
|
+
export const SqlMigration = message('sql.migration', { name: [1, str], text: [2, str] });
|
|
274
|
+
export const SqlDatabase = message('sql.database', {
|
|
275
|
+
name: [1, str],
|
|
276
|
+
migrations: [2, list(SqlMigration)],
|
|
277
|
+
});
|
|
278
|
+
export const SqlStatement = message('sql.statement', {
|
|
279
|
+
handle: [1, uint],
|
|
280
|
+
sql: [2, str],
|
|
281
|
+
args: [3, list(sqlValue)],
|
|
282
|
+
named: [4, names(sqlValue)],
|
|
283
|
+
write: [5, bool],
|
|
284
|
+
rows: [6, bool],
|
|
285
|
+
});
|
|
286
|
+
export const SqlStatements = message('sql.statements', {
|
|
287
|
+
handle: [1, uint],
|
|
288
|
+
statements: [2, list(SqlStatement)],
|
|
289
|
+
read: [3, bool],
|
|
290
|
+
jobs: [4, list(JobsBatch)],
|
|
291
|
+
});
|
|
292
|
+
export const SqlDone = message('sql.done', { changes: [1, int], lastId: [2, int] });
|
|
293
|
+
export const SqlColumns = message('sql.columns', { columns: [1, list(str)] });
|
|
294
|
+
export const SqlRow = message('sql.row', { values: [1, list(sqlValue)] });
|
|
295
|
+
export const SqlResult = message('sql.result', {
|
|
296
|
+
changes: [1, int],
|
|
297
|
+
lastId: [2, int],
|
|
298
|
+
columns: [3, list(str)],
|
|
299
|
+
rows: [4, list(list(sqlValue))],
|
|
300
|
+
});
|
|
301
|
+
export const SqlResults = message('sql.results', { results: [1, list(SqlResult)] });
|
|
302
|
+
export const RecordsRecord = message('records.record', {
|
|
303
|
+
at: [1, int64],
|
|
304
|
+
stream: [2, text],
|
|
305
|
+
name: [3, text],
|
|
306
|
+
level: [4, int],
|
|
307
|
+
body: [5, text],
|
|
308
|
+
traceId: [6, bin],
|
|
309
|
+
spanId: [7, bin],
|
|
310
|
+
context: [8, list(text)],
|
|
311
|
+
attrs: [9, list(text)],
|
|
312
|
+
});
|
|
313
|
+
export const RecordsBatch = message('records.batch', { records: [1, list(RecordsRecord)] });
|
|
314
|
+
export const RecordsQuery = message('records.query', {
|
|
315
|
+
from: [1, int64],
|
|
316
|
+
to: [2, int64],
|
|
317
|
+
streams: [3, list(text)],
|
|
318
|
+
names: [4, list(text)],
|
|
319
|
+
minLevel: [5, int],
|
|
320
|
+
traceId: [6, bin],
|
|
321
|
+
attrs: [7, list(text)],
|
|
322
|
+
context: [8, list(text)],
|
|
323
|
+
newest: [9, bool],
|
|
324
|
+
limit: [10, uint],
|
|
325
|
+
budgetBlocks: [11, uint],
|
|
326
|
+
budgetBytes: [12, uint],
|
|
327
|
+
budgetRecords: [13, uint],
|
|
328
|
+
search: [14, str],
|
|
329
|
+
});
|
|
330
|
+
export const RecordsPage = message('records.page', {
|
|
331
|
+
more: [1, bool],
|
|
332
|
+
from: [2, int64],
|
|
333
|
+
to: [3, int64],
|
|
334
|
+
});
|
|
335
|
+
export const RecordsCursor = message('records.cursor', {
|
|
336
|
+
segment: [1, int],
|
|
337
|
+
row: [2, int],
|
|
338
|
+
limit: [3, uint],
|
|
339
|
+
expired: [4, uint],
|
|
340
|
+
});
|
|
341
|
+
export const RecordsStream = message('records.stream', { stream: [1, text] });
|
|
342
|
+
export const RecordsDamage = message('records.damage', {
|
|
343
|
+
stream: [1, text],
|
|
344
|
+
segment: [2, int],
|
|
345
|
+
headRow: [3, int],
|
|
346
|
+
from: [4, int64],
|
|
347
|
+
to: [5, int64],
|
|
348
|
+
reason: [6, str],
|
|
349
|
+
});
|
|
350
|
+
export const RecordsDamages = message('records.damages', { damages: [1, list(RecordsDamage)] });
|
|
351
|
+
export const MetricsSeries = message('metrics.series', {
|
|
352
|
+
labels: [1, names(str)],
|
|
353
|
+
kind: [2, str],
|
|
354
|
+
times: [3, ints],
|
|
355
|
+
values: [4, floats],
|
|
356
|
+
});
|
|
357
|
+
export const MetricsBatch = message('metrics.batch', { series: [1, list(MetricsSeries)] });
|
|
358
|
+
export const MetricsPlan = message('metrics.plan', {
|
|
359
|
+
series: [1, uint],
|
|
360
|
+
blocks: [2, uint],
|
|
361
|
+
summarized: [3, uint],
|
|
362
|
+
bytes: [4, uint],
|
|
363
|
+
decoded: [5, uint],
|
|
364
|
+
limitSeries: [6, uint],
|
|
365
|
+
limitBlocks: [7, uint],
|
|
366
|
+
limitBytes: [8, uint],
|
|
367
|
+
limitDecoded: [9, uint],
|
|
368
|
+
limitAnswered: [10, uint],
|
|
369
|
+
stops: [11, nullable(Failure)],
|
|
370
|
+
});
|
|
371
|
+
export const MetricsCondition = message('metrics.condition', {
|
|
372
|
+
label: [1, str],
|
|
373
|
+
kind: [2, str],
|
|
374
|
+
values: [3, list(str)],
|
|
375
|
+
});
|
|
376
|
+
export const MetricsRange = message('metrics.range', {
|
|
377
|
+
matchers: [1, names(str)],
|
|
378
|
+
from: [2, int64],
|
|
379
|
+
to: [3, int64],
|
|
380
|
+
limitSeries: [4, uint],
|
|
381
|
+
limitBlocks: [5, uint],
|
|
382
|
+
limitBytes: [6, uint],
|
|
383
|
+
limitDecoded: [7, uint],
|
|
384
|
+
limitAnswered: [8, uint],
|
|
385
|
+
width: [9, uint],
|
|
386
|
+
op: [10, str],
|
|
387
|
+
where: [11, list(MetricsCondition)],
|
|
388
|
+
by: [12, list(str)],
|
|
389
|
+
without: [13, list(str)],
|
|
390
|
+
});
|
|
391
|
+
export const MetricsBuckets = message('metrics.buckets', {
|
|
392
|
+
labels: [1, names(str)],
|
|
393
|
+
kind: [2, str],
|
|
394
|
+
from: [3, ints],
|
|
395
|
+
to: [4, ints],
|
|
396
|
+
count: [5, ints],
|
|
397
|
+
resets: [6, ints],
|
|
398
|
+
values: [7, floats],
|
|
399
|
+
flags: [8, bin],
|
|
400
|
+
});
|
|
401
|
+
export const MetricsLabels = message('metrics.labels', { labels: [1, names(str)] });
|
|
402
|
+
export const MetricsDropped = message('metrics.dropped', {
|
|
403
|
+
found: [1, bool],
|
|
404
|
+
unreadableGroups: [2, uint],
|
|
405
|
+
});
|
|
406
|
+
/** Every message by the name messages.json gives it. */
|
|
407
|
+
export const messages = {
|
|
408
|
+
hello: Hello,
|
|
409
|
+
welcome: Welcome,
|
|
410
|
+
goaway: GoAway,
|
|
411
|
+
error: Failure,
|
|
412
|
+
handle: Handle,
|
|
413
|
+
empty: Empty,
|
|
414
|
+
clock: Clock,
|
|
415
|
+
'kv.bucket': KvBucket,
|
|
416
|
+
'kv.call': KvCall,
|
|
417
|
+
'kv.operation': KvOperation,
|
|
418
|
+
'kv.calls': KvCalls,
|
|
419
|
+
'kv.entry': KvEntry,
|
|
420
|
+
'kv.results': KvResults,
|
|
421
|
+
'kv.page': KvPage,
|
|
422
|
+
'kv.allowance': KvAllowance,
|
|
423
|
+
'kv.configure': KvConfigure,
|
|
424
|
+
'kv.kept': KvKept,
|
|
425
|
+
'jobs.queue': JobsQueue,
|
|
426
|
+
'jobs.repeat': JobsRepeat,
|
|
427
|
+
'jobs.job': JobsJob,
|
|
428
|
+
'jobs.batch': JobsBatch,
|
|
429
|
+
'jobs.change': JobsChange,
|
|
430
|
+
'jobs.key': JobsKey,
|
|
431
|
+
'jobs.answer': JobsAnswer,
|
|
432
|
+
'jobs.kept': JobsKept,
|
|
433
|
+
'jobs.entry': JobsEntry,
|
|
434
|
+
'jobs.lease': JobsLease,
|
|
435
|
+
'jobs.held': JobsHeld,
|
|
436
|
+
'jobs.outcome': JobsOutcome,
|
|
437
|
+
'jobs.outcomes': JobsOutcomes,
|
|
438
|
+
'jobs.settled': JobsSettled,
|
|
439
|
+
'jobs.query': JobsQuery,
|
|
440
|
+
'jobs.page': JobsPage,
|
|
441
|
+
'jobs.workers': JobsWorkers,
|
|
442
|
+
'blobs.bucket': BlobsBucket,
|
|
443
|
+
'blobs.call': BlobsCall,
|
|
444
|
+
'blobs.object': BlobsObject,
|
|
445
|
+
'blobs.total': BlobsTotal,
|
|
446
|
+
'blobs.page': BlobsPage,
|
|
447
|
+
'sql.database': SqlDatabase,
|
|
448
|
+
'sql.migration': SqlMigration,
|
|
449
|
+
'sql.statement': SqlStatement,
|
|
450
|
+
'sql.statements': SqlStatements,
|
|
451
|
+
'sql.done': SqlDone,
|
|
452
|
+
'sql.columns': SqlColumns,
|
|
453
|
+
'sql.row': SqlRow,
|
|
454
|
+
'sql.result': SqlResult,
|
|
455
|
+
'sql.results': SqlResults,
|
|
456
|
+
'records.record': RecordsRecord,
|
|
457
|
+
'records.batch': RecordsBatch,
|
|
458
|
+
'records.query': RecordsQuery,
|
|
459
|
+
'records.page': RecordsPage,
|
|
460
|
+
'records.cursor': RecordsCursor,
|
|
461
|
+
'records.stream': RecordsStream,
|
|
462
|
+
'records.damage': RecordsDamage,
|
|
463
|
+
'records.damages': RecordsDamages,
|
|
464
|
+
'metrics.series': MetricsSeries,
|
|
465
|
+
'metrics.batch': MetricsBatch,
|
|
466
|
+
'metrics.range': MetricsRange,
|
|
467
|
+
'metrics.condition': MetricsCondition,
|
|
468
|
+
'metrics.plan': MetricsPlan,
|
|
469
|
+
'metrics.buckets': MetricsBuckets,
|
|
470
|
+
'metrics.labels': MetricsLabels,
|
|
471
|
+
'metrics.dropped': MetricsDropped,
|
|
472
|
+
};
|
|
@@ -0,0 +1,93 @@
|
|
|
1
|
+
/** How deeply maps and arrays may nest in a message. */
|
|
2
|
+
export declare const maxDepth = 8;
|
|
3
|
+
/** Writes one message, its buffer growing as it must. */
|
|
4
|
+
export declare class Writer {
|
|
5
|
+
#private;
|
|
6
|
+
constructor(capacity?: number);
|
|
7
|
+
get length(): number;
|
|
8
|
+
/** A copy of what was written. */
|
|
9
|
+
bytes(): Uint8Array;
|
|
10
|
+
nil(): void;
|
|
11
|
+
bool(v: boolean): void;
|
|
12
|
+
/**
|
|
13
|
+
* Writes a value from 0 in the unsigned family's shortest form:
|
|
14
|
+
*
|
|
15
|
+
* 7 → 07 300 → cd 01 2c 70000 → ce 00 01 11 70
|
|
16
|
+
*/
|
|
17
|
+
uint(v: number | bigint): void;
|
|
18
|
+
/**
|
|
19
|
+
* Writes a value from 0 as uint does, and a negative one in the signed
|
|
20
|
+
* family's shortest form:
|
|
21
|
+
*
|
|
22
|
+
* -1 → ff -33 → d0 df -300 → d1 fe d4
|
|
23
|
+
*/
|
|
24
|
+
int(v: number | bigint): void;
|
|
25
|
+
/** Writes a float 64 with its bits: -0 → cb 80 00 00 00 00 00 00 00. */
|
|
26
|
+
float(v: number): void;
|
|
27
|
+
/**
|
|
28
|
+
* Writes text as UTF-8. A string holding a lone surrogate has no UTF-8 to
|
|
29
|
+
* write and is refused, rather than changed into U+FFFD.
|
|
30
|
+
*/
|
|
31
|
+
str(s: string): void;
|
|
32
|
+
bin(b: Uint8Array): void;
|
|
33
|
+
array(n: number): void;
|
|
34
|
+
map(n: number): void;
|
|
35
|
+
}
|
|
36
|
+
/** The kind of the next value a Reader holds. */
|
|
37
|
+
export type Type = 'nil' | 'bool' | 'int' | 'float' | 'str' | 'bin' | 'array' | 'map' | 'invalid';
|
|
38
|
+
/** The type a value's first byte says. */
|
|
39
|
+
export declare function typeOf(b: number): Type;
|
|
40
|
+
/**
|
|
41
|
+
* Reads one message and checks the profile as it goes: a value the profile
|
|
42
|
+
* refuses, one past the bytes left, or bytes after the message throw a
|
|
43
|
+
* ProtocolError. What it returns of the body, a bin, is a view of the body.
|
|
44
|
+
*/
|
|
45
|
+
export declare class Reader {
|
|
46
|
+
#private;
|
|
47
|
+
constructor(bytes: Uint8Array);
|
|
48
|
+
/** Refuses bytes left after the one value a message is. */
|
|
49
|
+
end(): void;
|
|
50
|
+
/** The next value's type, without reading it. */
|
|
51
|
+
type(): Type;
|
|
52
|
+
/** Reads an unsigned integer in any encoding of its value, a bigint. */
|
|
53
|
+
uint64(): bigint;
|
|
54
|
+
/** Reads a signed 64-bit integer in any encoding of its value, a bigint. */
|
|
55
|
+
int64(): bigint;
|
|
56
|
+
/** Reads an unsigned integer a number holds exactly. */
|
|
57
|
+
uint(): number;
|
|
58
|
+
/** Reads an integer a number holds exactly. */
|
|
59
|
+
int(): number;
|
|
60
|
+
/**
|
|
61
|
+
* Reads a float 64, or an integer a float 64 holds exactly, since a
|
|
62
|
+
* JavaScript encoder may write 3.0 as 3.
|
|
63
|
+
*/
|
|
64
|
+
float(): number;
|
|
65
|
+
bool(): boolean;
|
|
66
|
+
/** Reads a nil if one is next and says so, leaving any other value. */
|
|
67
|
+
nil(): boolean;
|
|
68
|
+
/** Reads a str, which must be valid UTF-8. */
|
|
69
|
+
str(): string;
|
|
70
|
+
/** Reads a bin as a view of the body; an empty one is an empty array. */
|
|
71
|
+
bin(): Uint8Array;
|
|
72
|
+
/**
|
|
73
|
+
* Reads an array's count and enters it; leave once its elements are read.
|
|
74
|
+
* A count past the bytes left is refused before anything is made of it,
|
|
75
|
+
* since every element takes at least a byte.
|
|
76
|
+
*/
|
|
77
|
+
array(): number;
|
|
78
|
+
/** Reads a map's count and enters it, each entry taking two bytes at least. */
|
|
79
|
+
map(): number;
|
|
80
|
+
leave(): void;
|
|
81
|
+
/**
|
|
82
|
+
* Reads a map with unsigned keys, a message or a field of one, calling each
|
|
83
|
+
* with its key and the value next: it reads the value, or returns false to
|
|
84
|
+
* have it skipped, well formed and within bounds. A key twice is refused.
|
|
85
|
+
*/
|
|
86
|
+
fields(each: (key: number) => boolean): void;
|
|
87
|
+
/** Reads a map of names, an error's what or a series' labels, as fields does. */
|
|
88
|
+
names(each: (name: string) => void): void;
|
|
89
|
+
/** Reads an array, calling each with an element's index and the element next. */
|
|
90
|
+
items(each: (index: number) => void): void;
|
|
91
|
+
/** Reads past one value, checking it is well formed as if it were read. */
|
|
92
|
+
skip(): void;
|
|
93
|
+
}
|