n8n-nodes-roblox 2.4.21 → 2.4.23
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 +22 -0
- package/dist/nodes/Roblox/RobloxCloud.node.js +7 -1
- package/dist/nodes/Roblox/RobloxCloud.node.js.map +1 -1
- package/dist/nodes/Roblox/RobloxLegacy.node.js +0 -1
- package/dist/nodes/Roblox/RobloxLegacy.node.js.map +1 -1
- package/dist/nodes/Roblox/Storage/StorageDescription.d.ts +3 -0
- package/dist/nodes/Roblox/Storage/StorageDescription.js +1181 -0
- package/dist/nodes/Roblox/Storage/StorageDescription.js.map +1 -0
- package/dist/package.json +1 -1
- package/dist/tsconfig.tsbuildinfo +1 -1
- package/package.json +1 -1
|
@@ -0,0 +1,1181 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.storageFields = exports.storageOperations = void 0;
|
|
4
|
+
const storageBaseUrl = '=/cloud/v2/universes/{{ $parameter["universeId"] }}';
|
|
5
|
+
const dataStoresUrl = `${storageBaseUrl}/data-stores`;
|
|
6
|
+
const dataStoreUrl = `${dataStoresUrl}/{{ $parameter["dataStoreId"] }}`;
|
|
7
|
+
const dataStoreEntriesUrl = `${dataStoreUrl}/entries`;
|
|
8
|
+
const scopedDataStoreEntriesUrl = `${dataStoreUrl}/scopes/{{ $parameter["scopeId"] }}/entries`;
|
|
9
|
+
const memoryStoreUrl = `${storageBaseUrl}/memory-store`;
|
|
10
|
+
const memoryStoreQueueUrl = `${memoryStoreUrl}/queues/{{ $parameter["queueId"] }}`;
|
|
11
|
+
const memoryStoreSortedMapUrl = `${memoryStoreUrl}/sorted-maps/{{ $parameter["sortedMapId"] }}`;
|
|
12
|
+
const orderedDataStoreEntriesUrl = `${storageBaseUrl}/ordered-data-stores/{{ $parameter["orderedDataStoreId"] }}` +
|
|
13
|
+
'/scopes/{{ $parameter["scopeId"] }}/entries';
|
|
14
|
+
const jsonBody = (parameterName) => `={{ JSON.parse($parameter["${parameterName}"] || "{}") }}`;
|
|
15
|
+
const dataStoreOperations = [
|
|
16
|
+
'delete_data_store',
|
|
17
|
+
'undelete_data_store',
|
|
18
|
+
'list_data_store_entries',
|
|
19
|
+
'create_data_store_entry',
|
|
20
|
+
'get_data_store_entry',
|
|
21
|
+
'update_data_store_entry',
|
|
22
|
+
'delete_data_store_entry',
|
|
23
|
+
'increment_data_store_entry',
|
|
24
|
+
'list_data_store_entry_revisions',
|
|
25
|
+
'list_scoped_data_store_entries',
|
|
26
|
+
'create_scoped_data_store_entry',
|
|
27
|
+
'get_scoped_data_store_entry',
|
|
28
|
+
'update_scoped_data_store_entry',
|
|
29
|
+
'delete_scoped_data_store_entry',
|
|
30
|
+
'increment_scoped_data_store_entry',
|
|
31
|
+
'list_scoped_data_store_entry_revisions',
|
|
32
|
+
];
|
|
33
|
+
const dataStoreEntryOperations = [
|
|
34
|
+
'get_data_store_entry',
|
|
35
|
+
'update_data_store_entry',
|
|
36
|
+
'delete_data_store_entry',
|
|
37
|
+
'increment_data_store_entry',
|
|
38
|
+
'list_data_store_entry_revisions',
|
|
39
|
+
];
|
|
40
|
+
const scopedDataStoreOperations = [
|
|
41
|
+
'list_scoped_data_store_entries',
|
|
42
|
+
'create_scoped_data_store_entry',
|
|
43
|
+
'get_scoped_data_store_entry',
|
|
44
|
+
'update_scoped_data_store_entry',
|
|
45
|
+
'delete_scoped_data_store_entry',
|
|
46
|
+
'increment_scoped_data_store_entry',
|
|
47
|
+
'list_scoped_data_store_entry_revisions',
|
|
48
|
+
];
|
|
49
|
+
const scopedDataStoreEntryOperations = [
|
|
50
|
+
'get_scoped_data_store_entry',
|
|
51
|
+
'update_scoped_data_store_entry',
|
|
52
|
+
'delete_scoped_data_store_entry',
|
|
53
|
+
'increment_scoped_data_store_entry',
|
|
54
|
+
'list_scoped_data_store_entry_revisions',
|
|
55
|
+
];
|
|
56
|
+
const memoryStoreQueueOperations = [
|
|
57
|
+
'create_memory_store_queue_item',
|
|
58
|
+
'read_memory_store_queue_items',
|
|
59
|
+
'discard_memory_store_queue_items',
|
|
60
|
+
];
|
|
61
|
+
const memoryStoreSortedMapOperations = [
|
|
62
|
+
'list_memory_store_sorted_map_items',
|
|
63
|
+
'create_memory_store_sorted_map_item',
|
|
64
|
+
'get_memory_store_sorted_map_item',
|
|
65
|
+
'update_memory_store_sorted_map_item',
|
|
66
|
+
'delete_memory_store_sorted_map_item',
|
|
67
|
+
];
|
|
68
|
+
const memoryStoreSortedMapItemOperations = [
|
|
69
|
+
'get_memory_store_sorted_map_item',
|
|
70
|
+
'update_memory_store_sorted_map_item',
|
|
71
|
+
'delete_memory_store_sorted_map_item',
|
|
72
|
+
];
|
|
73
|
+
const orderedDataStoreOperations = [
|
|
74
|
+
'list_ordered_data_store_entries',
|
|
75
|
+
'create_ordered_data_store_entry',
|
|
76
|
+
'get_ordered_data_store_entry',
|
|
77
|
+
'update_ordered_data_store_entry',
|
|
78
|
+
'delete_ordered_data_store_entry',
|
|
79
|
+
'increment_ordered_data_store_entry',
|
|
80
|
+
];
|
|
81
|
+
const orderedDataStoreEntryOperations = [
|
|
82
|
+
'get_ordered_data_store_entry',
|
|
83
|
+
'update_ordered_data_store_entry',
|
|
84
|
+
'delete_ordered_data_store_entry',
|
|
85
|
+
'increment_ordered_data_store_entry',
|
|
86
|
+
];
|
|
87
|
+
const storageOperationsWithUniverse = [
|
|
88
|
+
'list_data_stores',
|
|
89
|
+
'snapshot_data_stores',
|
|
90
|
+
'flush_memory_store',
|
|
91
|
+
'get_memory_store_flush_operation',
|
|
92
|
+
...dataStoreOperations,
|
|
93
|
+
...memoryStoreQueueOperations,
|
|
94
|
+
...memoryStoreSortedMapOperations,
|
|
95
|
+
...orderedDataStoreOperations,
|
|
96
|
+
];
|
|
97
|
+
exports.storageOperations = [
|
|
98
|
+
{
|
|
99
|
+
displayName: 'Operation',
|
|
100
|
+
name: 'operation',
|
|
101
|
+
type: 'options',
|
|
102
|
+
noDataExpression: true,
|
|
103
|
+
displayOptions: {
|
|
104
|
+
show: {
|
|
105
|
+
resource: ['storage'],
|
|
106
|
+
},
|
|
107
|
+
},
|
|
108
|
+
options: [
|
|
109
|
+
{
|
|
110
|
+
name: 'Create Data Store Entry',
|
|
111
|
+
value: 'create_data_store_entry',
|
|
112
|
+
description: 'Create a data store entry',
|
|
113
|
+
action: 'Create data store entry',
|
|
114
|
+
routing: {
|
|
115
|
+
request: {
|
|
116
|
+
method: 'POST',
|
|
117
|
+
url: dataStoreEntriesUrl,
|
|
118
|
+
qs: {
|
|
119
|
+
id: '={{ $parameter["data_store_create_query"].id }}',
|
|
120
|
+
},
|
|
121
|
+
body: jsonBody('dataStoreEntryJson'),
|
|
122
|
+
},
|
|
123
|
+
},
|
|
124
|
+
},
|
|
125
|
+
{
|
|
126
|
+
name: 'Create Memory Store Queue Item',
|
|
127
|
+
value: 'create_memory_store_queue_item',
|
|
128
|
+
description: 'Create a memory store queue item',
|
|
129
|
+
action: 'Create memory store queue item',
|
|
130
|
+
routing: {
|
|
131
|
+
request: {
|
|
132
|
+
method: 'POST',
|
|
133
|
+
url: `${memoryStoreQueueUrl}/items`,
|
|
134
|
+
body: jsonBody('memoryStoreQueueItemJson'),
|
|
135
|
+
},
|
|
136
|
+
},
|
|
137
|
+
},
|
|
138
|
+
{
|
|
139
|
+
name: 'Create Memory Store Sorted Map Item',
|
|
140
|
+
value: 'create_memory_store_sorted_map_item',
|
|
141
|
+
description: 'Create a memory store sorted map item',
|
|
142
|
+
action: 'Create memory store sorted map item',
|
|
143
|
+
routing: {
|
|
144
|
+
request: {
|
|
145
|
+
method: 'POST',
|
|
146
|
+
url: `${memoryStoreSortedMapUrl}/items`,
|
|
147
|
+
qs: {
|
|
148
|
+
id: '={{ $parameter["memory_store_sorted_map_create_query"].id }}',
|
|
149
|
+
},
|
|
150
|
+
body: jsonBody('memoryStoreSortedMapItemJson'),
|
|
151
|
+
},
|
|
152
|
+
},
|
|
153
|
+
},
|
|
154
|
+
{
|
|
155
|
+
name: 'Create Ordered Data Store Entry',
|
|
156
|
+
value: 'create_ordered_data_store_entry',
|
|
157
|
+
description: 'Create an ordered data store entry',
|
|
158
|
+
action: 'Create ordered data store entry',
|
|
159
|
+
routing: {
|
|
160
|
+
request: {
|
|
161
|
+
method: 'POST',
|
|
162
|
+
url: orderedDataStoreEntriesUrl,
|
|
163
|
+
qs: {
|
|
164
|
+
id: '={{ $parameter["ordered_data_store_create_query"].id }}',
|
|
165
|
+
},
|
|
166
|
+
body: jsonBody('orderedDataStoreEntryJson'),
|
|
167
|
+
},
|
|
168
|
+
},
|
|
169
|
+
},
|
|
170
|
+
{
|
|
171
|
+
name: 'Create Scoped Data Store Entry',
|
|
172
|
+
value: 'create_scoped_data_store_entry',
|
|
173
|
+
description: 'Create a data store entry in a scope',
|
|
174
|
+
action: 'Create scoped data store entry',
|
|
175
|
+
routing: {
|
|
176
|
+
request: {
|
|
177
|
+
method: 'POST',
|
|
178
|
+
url: scopedDataStoreEntriesUrl,
|
|
179
|
+
qs: {
|
|
180
|
+
id: '={{ $parameter["data_store_create_query"].id }}',
|
|
181
|
+
},
|
|
182
|
+
body: jsonBody('dataStoreEntryJson'),
|
|
183
|
+
},
|
|
184
|
+
},
|
|
185
|
+
},
|
|
186
|
+
{
|
|
187
|
+
name: 'Delete Data Store',
|
|
188
|
+
value: 'delete_data_store',
|
|
189
|
+
description: 'Delete a data store',
|
|
190
|
+
action: 'Delete data store',
|
|
191
|
+
routing: {
|
|
192
|
+
request: {
|
|
193
|
+
method: 'DELETE',
|
|
194
|
+
url: dataStoreUrl,
|
|
195
|
+
},
|
|
196
|
+
},
|
|
197
|
+
},
|
|
198
|
+
{
|
|
199
|
+
name: 'Delete Data Store Entry',
|
|
200
|
+
value: 'delete_data_store_entry',
|
|
201
|
+
description: 'Delete a data store entry',
|
|
202
|
+
action: 'Delete data store entry',
|
|
203
|
+
routing: {
|
|
204
|
+
request: {
|
|
205
|
+
method: 'DELETE',
|
|
206
|
+
url: `${dataStoreEntriesUrl}/{{ $parameter["entryId"] }}`,
|
|
207
|
+
},
|
|
208
|
+
},
|
|
209
|
+
},
|
|
210
|
+
{
|
|
211
|
+
name: 'Delete Memory Store Sorted Map Item',
|
|
212
|
+
value: 'delete_memory_store_sorted_map_item',
|
|
213
|
+
description: 'Delete a memory store sorted map item',
|
|
214
|
+
action: 'Delete memory store sorted map item',
|
|
215
|
+
routing: {
|
|
216
|
+
request: {
|
|
217
|
+
method: 'DELETE',
|
|
218
|
+
url: `${memoryStoreSortedMapUrl}/items/{{ $parameter["itemId"] }}`,
|
|
219
|
+
},
|
|
220
|
+
},
|
|
221
|
+
},
|
|
222
|
+
{
|
|
223
|
+
name: 'Delete Ordered Data Store Entry',
|
|
224
|
+
value: 'delete_ordered_data_store_entry',
|
|
225
|
+
description: 'Delete an ordered data store entry',
|
|
226
|
+
action: 'Delete ordered data store entry',
|
|
227
|
+
routing: {
|
|
228
|
+
request: {
|
|
229
|
+
method: 'DELETE',
|
|
230
|
+
url: `${orderedDataStoreEntriesUrl}/{{ $parameter["entryId"] }}`,
|
|
231
|
+
},
|
|
232
|
+
},
|
|
233
|
+
},
|
|
234
|
+
{
|
|
235
|
+
name: 'Delete Scoped Data Store Entry',
|
|
236
|
+
value: 'delete_scoped_data_store_entry',
|
|
237
|
+
description: 'Delete a data store entry in a scope',
|
|
238
|
+
action: 'Delete scoped data store entry',
|
|
239
|
+
routing: {
|
|
240
|
+
request: {
|
|
241
|
+
method: 'DELETE',
|
|
242
|
+
url: `${scopedDataStoreEntriesUrl}/{{ $parameter["entryId"] }}`,
|
|
243
|
+
},
|
|
244
|
+
},
|
|
245
|
+
},
|
|
246
|
+
{
|
|
247
|
+
name: 'Discard Memory Store Queue Items',
|
|
248
|
+
value: 'discard_memory_store_queue_items',
|
|
249
|
+
description: 'Discard previously read memory store queue items',
|
|
250
|
+
action: 'Discard memory store queue items',
|
|
251
|
+
routing: {
|
|
252
|
+
request: {
|
|
253
|
+
method: 'POST',
|
|
254
|
+
url: `${memoryStoreQueueUrl}/items:discard`,
|
|
255
|
+
body: jsonBody('discardMemoryStoreQueueItemsJson'),
|
|
256
|
+
},
|
|
257
|
+
},
|
|
258
|
+
},
|
|
259
|
+
{
|
|
260
|
+
name: 'Flush Memory Store',
|
|
261
|
+
value: 'flush_memory_store',
|
|
262
|
+
description: 'Flush memory stores for a universe',
|
|
263
|
+
action: 'Flush memory store',
|
|
264
|
+
routing: {
|
|
265
|
+
request: {
|
|
266
|
+
method: 'POST',
|
|
267
|
+
url: `${memoryStoreUrl}:flush`,
|
|
268
|
+
body: {},
|
|
269
|
+
},
|
|
270
|
+
},
|
|
271
|
+
},
|
|
272
|
+
{
|
|
273
|
+
name: 'Get Data Store Entry',
|
|
274
|
+
value: 'get_data_store_entry',
|
|
275
|
+
description: 'Get a data store entry',
|
|
276
|
+
action: 'Get data store entry',
|
|
277
|
+
routing: {
|
|
278
|
+
request: {
|
|
279
|
+
method: 'GET',
|
|
280
|
+
url: `${dataStoreEntriesUrl}/{{ $parameter["entryId"] }}`,
|
|
281
|
+
},
|
|
282
|
+
},
|
|
283
|
+
},
|
|
284
|
+
{
|
|
285
|
+
name: 'Get Memory Store Flush Operation',
|
|
286
|
+
value: 'get_memory_store_flush_operation',
|
|
287
|
+
description: 'Get a memory store flush operation',
|
|
288
|
+
action: 'Get memory store flush operation',
|
|
289
|
+
routing: {
|
|
290
|
+
request: {
|
|
291
|
+
method: 'GET',
|
|
292
|
+
url: `${memoryStoreUrl}/operations/{{ $parameter["operationId"] }}`,
|
|
293
|
+
},
|
|
294
|
+
},
|
|
295
|
+
},
|
|
296
|
+
{
|
|
297
|
+
name: 'Get Memory Store Sorted Map Item',
|
|
298
|
+
value: 'get_memory_store_sorted_map_item',
|
|
299
|
+
description: 'Get a memory store sorted map item',
|
|
300
|
+
action: 'Get memory store sorted map item',
|
|
301
|
+
routing: {
|
|
302
|
+
request: {
|
|
303
|
+
method: 'GET',
|
|
304
|
+
url: `${memoryStoreSortedMapUrl}/items/{{ $parameter["itemId"] }}`,
|
|
305
|
+
},
|
|
306
|
+
},
|
|
307
|
+
},
|
|
308
|
+
{
|
|
309
|
+
name: 'Get Ordered Data Store Entry',
|
|
310
|
+
value: 'get_ordered_data_store_entry',
|
|
311
|
+
description: 'Get an ordered data store entry',
|
|
312
|
+
action: 'Get ordered data store entry',
|
|
313
|
+
routing: {
|
|
314
|
+
request: {
|
|
315
|
+
method: 'GET',
|
|
316
|
+
url: `${orderedDataStoreEntriesUrl}/{{ $parameter["entryId"] }}`,
|
|
317
|
+
},
|
|
318
|
+
},
|
|
319
|
+
},
|
|
320
|
+
{
|
|
321
|
+
name: 'Get Scoped Data Store Entry',
|
|
322
|
+
value: 'get_scoped_data_store_entry',
|
|
323
|
+
description: 'Get a data store entry in a scope',
|
|
324
|
+
action: 'Get scoped data store entry',
|
|
325
|
+
routing: {
|
|
326
|
+
request: {
|
|
327
|
+
method: 'GET',
|
|
328
|
+
url: `${scopedDataStoreEntriesUrl}/{{ $parameter["entryId"] }}`,
|
|
329
|
+
},
|
|
330
|
+
},
|
|
331
|
+
},
|
|
332
|
+
{
|
|
333
|
+
name: 'Increment Data Store Entry',
|
|
334
|
+
value: 'increment_data_store_entry',
|
|
335
|
+
description: 'Increment a data store entry value',
|
|
336
|
+
action: 'Increment data store entry',
|
|
337
|
+
routing: {
|
|
338
|
+
request: {
|
|
339
|
+
method: 'POST',
|
|
340
|
+
url: `${dataStoreEntriesUrl}/{{ $parameter["entryId"] }}:increment`,
|
|
341
|
+
body: jsonBody('incrementDataStoreEntryJson'),
|
|
342
|
+
},
|
|
343
|
+
},
|
|
344
|
+
},
|
|
345
|
+
{
|
|
346
|
+
name: 'Increment Ordered Data Store Entry',
|
|
347
|
+
value: 'increment_ordered_data_store_entry',
|
|
348
|
+
description: 'Increment an ordered data store entry value',
|
|
349
|
+
action: 'Increment ordered data store entry',
|
|
350
|
+
routing: {
|
|
351
|
+
request: {
|
|
352
|
+
method: 'POST',
|
|
353
|
+
url: `${orderedDataStoreEntriesUrl}/{{ $parameter["entryId"] }}:increment`,
|
|
354
|
+
body: jsonBody('incrementOrderedDataStoreEntryJson'),
|
|
355
|
+
},
|
|
356
|
+
},
|
|
357
|
+
},
|
|
358
|
+
{
|
|
359
|
+
name: 'Increment Scoped Data Store Entry',
|
|
360
|
+
value: 'increment_scoped_data_store_entry',
|
|
361
|
+
description: 'Increment a scoped data store entry value',
|
|
362
|
+
action: 'Increment scoped data store entry',
|
|
363
|
+
routing: {
|
|
364
|
+
request: {
|
|
365
|
+
method: 'POST',
|
|
366
|
+
url: `${scopedDataStoreEntriesUrl}/{{ $parameter["entryId"] }}:increment`,
|
|
367
|
+
body: jsonBody('incrementDataStoreEntryJson'),
|
|
368
|
+
},
|
|
369
|
+
},
|
|
370
|
+
},
|
|
371
|
+
{
|
|
372
|
+
name: 'List Data Store Entries',
|
|
373
|
+
value: 'list_data_store_entries',
|
|
374
|
+
action: 'List data store entries',
|
|
375
|
+
routing: {
|
|
376
|
+
request: {
|
|
377
|
+
method: 'GET',
|
|
378
|
+
url: dataStoreEntriesUrl,
|
|
379
|
+
qs: {
|
|
380
|
+
maxPageSize: '={{ $parameter["data_store_list_query"].maxPageSize }}',
|
|
381
|
+
pageToken: '={{ $parameter["data_store_list_query"].pageToken }}',
|
|
382
|
+
filter: '={{ $parameter["data_store_list_query"].filter }}',
|
|
383
|
+
showDeleted: '={{ $parameter["data_store_list_query"].showDeleted }}',
|
|
384
|
+
},
|
|
385
|
+
},
|
|
386
|
+
},
|
|
387
|
+
},
|
|
388
|
+
{
|
|
389
|
+
name: 'List Data Store Entry Revisions',
|
|
390
|
+
value: 'list_data_store_entry_revisions',
|
|
391
|
+
action: 'List data store entry revisions',
|
|
392
|
+
routing: {
|
|
393
|
+
request: {
|
|
394
|
+
method: 'GET',
|
|
395
|
+
url: `${dataStoreEntriesUrl}/{{ $parameter["entryId"] }}:listRevisions`,
|
|
396
|
+
qs: {
|
|
397
|
+
maxPageSize: '={{ $parameter["data_store_revision_query"].maxPageSize }}',
|
|
398
|
+
pageToken: '={{ $parameter["data_store_revision_query"].pageToken }}',
|
|
399
|
+
filter: '={{ $parameter["data_store_revision_query"].filter }}',
|
|
400
|
+
},
|
|
401
|
+
},
|
|
402
|
+
},
|
|
403
|
+
},
|
|
404
|
+
{
|
|
405
|
+
name: 'List Data Stores',
|
|
406
|
+
value: 'list_data_stores',
|
|
407
|
+
description: 'List data stores in a universe',
|
|
408
|
+
action: 'List data stores',
|
|
409
|
+
routing: {
|
|
410
|
+
request: {
|
|
411
|
+
method: 'GET',
|
|
412
|
+
url: dataStoresUrl,
|
|
413
|
+
qs: {
|
|
414
|
+
maxPageSize: '={{ $parameter["data_store_list_query"].maxPageSize }}',
|
|
415
|
+
pageToken: '={{ $parameter["data_store_list_query"].pageToken }}',
|
|
416
|
+
filter: '={{ $parameter["data_store_list_query"].filter }}',
|
|
417
|
+
showDeleted: '={{ $parameter["data_store_list_query"].showDeleted }}',
|
|
418
|
+
},
|
|
419
|
+
},
|
|
420
|
+
},
|
|
421
|
+
},
|
|
422
|
+
{
|
|
423
|
+
name: 'List Memory Store Sorted Map Items',
|
|
424
|
+
value: 'list_memory_store_sorted_map_items',
|
|
425
|
+
action: 'List memory store sorted map items',
|
|
426
|
+
routing: {
|
|
427
|
+
request: {
|
|
428
|
+
method: 'GET',
|
|
429
|
+
url: `${memoryStoreSortedMapUrl}/items`,
|
|
430
|
+
qs: {
|
|
431
|
+
maxPageSize: '={{ $parameter["memory_store_sorted_map_list_query"].maxPageSize }}',
|
|
432
|
+
pageToken: '={{ $parameter["memory_store_sorted_map_list_query"].pageToken }}',
|
|
433
|
+
orderBy: '={{ $parameter["memory_store_sorted_map_list_query"].orderBy }}',
|
|
434
|
+
filter: '={{ $parameter["memory_store_sorted_map_list_query"].filter }}',
|
|
435
|
+
},
|
|
436
|
+
},
|
|
437
|
+
},
|
|
438
|
+
},
|
|
439
|
+
{
|
|
440
|
+
name: 'List Ordered Data Store Entries',
|
|
441
|
+
value: 'list_ordered_data_store_entries',
|
|
442
|
+
action: 'List ordered data store entries',
|
|
443
|
+
routing: {
|
|
444
|
+
request: {
|
|
445
|
+
method: 'GET',
|
|
446
|
+
url: orderedDataStoreEntriesUrl,
|
|
447
|
+
qs: {
|
|
448
|
+
maxPageSize: '={{ $parameter["ordered_data_store_list_query"].maxPageSize }}',
|
|
449
|
+
pageToken: '={{ $parameter["ordered_data_store_list_query"].pageToken }}',
|
|
450
|
+
orderBy: '={{ $parameter["ordered_data_store_list_query"].orderBy }}',
|
|
451
|
+
filter: '={{ $parameter["ordered_data_store_list_query"].filter }}',
|
|
452
|
+
},
|
|
453
|
+
},
|
|
454
|
+
},
|
|
455
|
+
},
|
|
456
|
+
{
|
|
457
|
+
name: 'List Scoped Data Store Entries',
|
|
458
|
+
value: 'list_scoped_data_store_entries',
|
|
459
|
+
description: 'List data store entries in a scope',
|
|
460
|
+
action: 'List scoped data store entries',
|
|
461
|
+
routing: {
|
|
462
|
+
request: {
|
|
463
|
+
method: 'GET',
|
|
464
|
+
url: scopedDataStoreEntriesUrl,
|
|
465
|
+
qs: {
|
|
466
|
+
maxPageSize: '={{ $parameter["data_store_list_query"].maxPageSize }}',
|
|
467
|
+
pageToken: '={{ $parameter["data_store_list_query"].pageToken }}',
|
|
468
|
+
filter: '={{ $parameter["data_store_list_query"].filter }}',
|
|
469
|
+
showDeleted: '={{ $parameter["data_store_list_query"].showDeleted }}',
|
|
470
|
+
},
|
|
471
|
+
},
|
|
472
|
+
},
|
|
473
|
+
},
|
|
474
|
+
{
|
|
475
|
+
name: 'List Scoped Data Store Entry Revisions',
|
|
476
|
+
value: 'list_scoped_data_store_entry_revisions',
|
|
477
|
+
action: 'List scoped data store entry revisions',
|
|
478
|
+
routing: {
|
|
479
|
+
request: {
|
|
480
|
+
method: 'GET',
|
|
481
|
+
url: `${scopedDataStoreEntriesUrl}/{{ $parameter["entryId"] }}:listRevisions`,
|
|
482
|
+
qs: {
|
|
483
|
+
maxPageSize: '={{ $parameter["data_store_revision_query"].maxPageSize }}',
|
|
484
|
+
pageToken: '={{ $parameter["data_store_revision_query"].pageToken }}',
|
|
485
|
+
filter: '={{ $parameter["data_store_revision_query"].filter }}',
|
|
486
|
+
},
|
|
487
|
+
},
|
|
488
|
+
},
|
|
489
|
+
},
|
|
490
|
+
{
|
|
491
|
+
name: 'Read Memory Store Queue Items',
|
|
492
|
+
value: 'read_memory_store_queue_items',
|
|
493
|
+
action: 'Read memory store queue items',
|
|
494
|
+
routing: {
|
|
495
|
+
request: {
|
|
496
|
+
method: 'GET',
|
|
497
|
+
url: `${memoryStoreQueueUrl}/items:read`,
|
|
498
|
+
qs: {
|
|
499
|
+
count: '={{ $parameter["memory_store_queue_read_query"].count }}',
|
|
500
|
+
allOrNothing: '={{ $parameter["memory_store_queue_read_query"].allOrNothing }}',
|
|
501
|
+
invisibilityWindow: '={{ $parameter["memory_store_queue_read_query"].invisibilityWindow }}',
|
|
502
|
+
},
|
|
503
|
+
},
|
|
504
|
+
},
|
|
505
|
+
},
|
|
506
|
+
{
|
|
507
|
+
name: 'Snapshot Data Stores',
|
|
508
|
+
value: 'snapshot_data_stores',
|
|
509
|
+
description: 'Snapshot data stores in a universe',
|
|
510
|
+
action: 'Snapshot data stores',
|
|
511
|
+
routing: {
|
|
512
|
+
request: {
|
|
513
|
+
method: 'POST',
|
|
514
|
+
url: `${dataStoresUrl}:snapshot`,
|
|
515
|
+
body: {},
|
|
516
|
+
},
|
|
517
|
+
},
|
|
518
|
+
},
|
|
519
|
+
{
|
|
520
|
+
name: 'Undelete Data Store',
|
|
521
|
+
value: 'undelete_data_store',
|
|
522
|
+
description: 'Undelete a data store',
|
|
523
|
+
action: 'Undelete data store',
|
|
524
|
+
routing: {
|
|
525
|
+
request: {
|
|
526
|
+
method: 'POST',
|
|
527
|
+
url: `${dataStoreUrl}:undelete`,
|
|
528
|
+
body: {},
|
|
529
|
+
},
|
|
530
|
+
},
|
|
531
|
+
},
|
|
532
|
+
{
|
|
533
|
+
name: 'Update Data Store Entry',
|
|
534
|
+
value: 'update_data_store_entry',
|
|
535
|
+
description: 'Update a data store entry',
|
|
536
|
+
action: 'Update data store entry',
|
|
537
|
+
routing: {
|
|
538
|
+
request: {
|
|
539
|
+
method: 'PATCH',
|
|
540
|
+
url: `${dataStoreEntriesUrl}/{{ $parameter["entryId"] }}`,
|
|
541
|
+
qs: {
|
|
542
|
+
allowMissing: '={{ $parameter["data_store_update_query"].allowMissing }}',
|
|
543
|
+
},
|
|
544
|
+
body: jsonBody('dataStoreEntryJson'),
|
|
545
|
+
},
|
|
546
|
+
},
|
|
547
|
+
},
|
|
548
|
+
{
|
|
549
|
+
name: 'Update Memory Store Sorted Map Item',
|
|
550
|
+
value: 'update_memory_store_sorted_map_item',
|
|
551
|
+
description: 'Update a memory store sorted map item',
|
|
552
|
+
action: 'Update memory store sorted map item',
|
|
553
|
+
routing: {
|
|
554
|
+
request: {
|
|
555
|
+
method: 'PATCH',
|
|
556
|
+
url: `${memoryStoreSortedMapUrl}/items/{{ $parameter["itemId"] }}`,
|
|
557
|
+
qs: {
|
|
558
|
+
allowMissing: '={{ $parameter["memory_store_sorted_map_update_query"].allowMissing }}',
|
|
559
|
+
},
|
|
560
|
+
body: jsonBody('memoryStoreSortedMapItemJson'),
|
|
561
|
+
},
|
|
562
|
+
},
|
|
563
|
+
},
|
|
564
|
+
{
|
|
565
|
+
name: 'Update Ordered Data Store Entry',
|
|
566
|
+
value: 'update_ordered_data_store_entry',
|
|
567
|
+
description: 'Update an ordered data store entry',
|
|
568
|
+
action: 'Update ordered data store entry',
|
|
569
|
+
routing: {
|
|
570
|
+
request: {
|
|
571
|
+
method: 'PATCH',
|
|
572
|
+
url: `${orderedDataStoreEntriesUrl}/{{ $parameter["entryId"] }}`,
|
|
573
|
+
qs: {
|
|
574
|
+
allowMissing: '={{ $parameter["ordered_data_store_update_query"].allowMissing }}',
|
|
575
|
+
},
|
|
576
|
+
body: jsonBody('orderedDataStoreEntryJson'),
|
|
577
|
+
},
|
|
578
|
+
},
|
|
579
|
+
},
|
|
580
|
+
{
|
|
581
|
+
name: 'Update Scoped Data Store Entry',
|
|
582
|
+
value: 'update_scoped_data_store_entry',
|
|
583
|
+
description: 'Update a data store entry in a scope',
|
|
584
|
+
action: 'Update scoped data store entry',
|
|
585
|
+
routing: {
|
|
586
|
+
request: {
|
|
587
|
+
method: 'PATCH',
|
|
588
|
+
url: `${scopedDataStoreEntriesUrl}/{{ $parameter["entryId"] }}`,
|
|
589
|
+
qs: {
|
|
590
|
+
allowMissing: '={{ $parameter["data_store_update_query"].allowMissing }}',
|
|
591
|
+
},
|
|
592
|
+
body: jsonBody('dataStoreEntryJson'),
|
|
593
|
+
},
|
|
594
|
+
},
|
|
595
|
+
},
|
|
596
|
+
],
|
|
597
|
+
default: 'list_data_stores',
|
|
598
|
+
},
|
|
599
|
+
];
|
|
600
|
+
exports.storageFields = [
|
|
601
|
+
{
|
|
602
|
+
displayName: 'Universe ID',
|
|
603
|
+
name: 'universeId',
|
|
604
|
+
type: 'string',
|
|
605
|
+
default: '',
|
|
606
|
+
required: true,
|
|
607
|
+
description: 'The universe ID that owns the storage resource',
|
|
608
|
+
displayOptions: {
|
|
609
|
+
show: {
|
|
610
|
+
resource: ['storage'],
|
|
611
|
+
operation: storageOperationsWithUniverse,
|
|
612
|
+
},
|
|
613
|
+
},
|
|
614
|
+
},
|
|
615
|
+
{
|
|
616
|
+
displayName: 'Data Store ID',
|
|
617
|
+
name: 'dataStoreId',
|
|
618
|
+
type: 'string',
|
|
619
|
+
default: '',
|
|
620
|
+
required: true,
|
|
621
|
+
displayOptions: {
|
|
622
|
+
show: {
|
|
623
|
+
resource: ['storage'],
|
|
624
|
+
operation: dataStoreOperations,
|
|
625
|
+
},
|
|
626
|
+
},
|
|
627
|
+
},
|
|
628
|
+
{
|
|
629
|
+
displayName: 'Scope ID',
|
|
630
|
+
name: 'scopeId',
|
|
631
|
+
type: 'string',
|
|
632
|
+
default: '',
|
|
633
|
+
required: true,
|
|
634
|
+
description: 'The data store or ordered data store scope ID',
|
|
635
|
+
displayOptions: {
|
|
636
|
+
show: {
|
|
637
|
+
resource: ['storage'],
|
|
638
|
+
operation: [...scopedDataStoreOperations, ...orderedDataStoreOperations],
|
|
639
|
+
},
|
|
640
|
+
},
|
|
641
|
+
},
|
|
642
|
+
{
|
|
643
|
+
displayName: 'Entry ID',
|
|
644
|
+
name: 'entryId',
|
|
645
|
+
type: 'string',
|
|
646
|
+
default: '',
|
|
647
|
+
required: true,
|
|
648
|
+
displayOptions: {
|
|
649
|
+
show: {
|
|
650
|
+
resource: ['storage'],
|
|
651
|
+
operation: [
|
|
652
|
+
...dataStoreEntryOperations,
|
|
653
|
+
...scopedDataStoreEntryOperations,
|
|
654
|
+
...orderedDataStoreEntryOperations,
|
|
655
|
+
],
|
|
656
|
+
},
|
|
657
|
+
},
|
|
658
|
+
},
|
|
659
|
+
{
|
|
660
|
+
displayName: 'Queue ID',
|
|
661
|
+
name: 'queueId',
|
|
662
|
+
type: 'string',
|
|
663
|
+
default: '',
|
|
664
|
+
required: true,
|
|
665
|
+
description: 'The memory store queue ID',
|
|
666
|
+
displayOptions: {
|
|
667
|
+
show: {
|
|
668
|
+
resource: ['storage'],
|
|
669
|
+
operation: memoryStoreQueueOperations,
|
|
670
|
+
},
|
|
671
|
+
},
|
|
672
|
+
},
|
|
673
|
+
{
|
|
674
|
+
displayName: 'Sorted Map ID',
|
|
675
|
+
name: 'sortedMapId',
|
|
676
|
+
type: 'string',
|
|
677
|
+
default: '',
|
|
678
|
+
required: true,
|
|
679
|
+
description: 'The memory store sorted map ID',
|
|
680
|
+
displayOptions: {
|
|
681
|
+
show: {
|
|
682
|
+
resource: ['storage'],
|
|
683
|
+
operation: memoryStoreSortedMapOperations,
|
|
684
|
+
},
|
|
685
|
+
},
|
|
686
|
+
},
|
|
687
|
+
{
|
|
688
|
+
displayName: 'Item ID',
|
|
689
|
+
name: 'itemId',
|
|
690
|
+
type: 'string',
|
|
691
|
+
default: '',
|
|
692
|
+
required: true,
|
|
693
|
+
description: 'The memory store sorted map item ID',
|
|
694
|
+
displayOptions: {
|
|
695
|
+
show: {
|
|
696
|
+
resource: ['storage'],
|
|
697
|
+
operation: memoryStoreSortedMapItemOperations,
|
|
698
|
+
},
|
|
699
|
+
},
|
|
700
|
+
},
|
|
701
|
+
{
|
|
702
|
+
displayName: 'Ordered Data Store ID',
|
|
703
|
+
name: 'orderedDataStoreId',
|
|
704
|
+
type: 'string',
|
|
705
|
+
default: '',
|
|
706
|
+
required: true,
|
|
707
|
+
displayOptions: {
|
|
708
|
+
show: {
|
|
709
|
+
resource: ['storage'],
|
|
710
|
+
operation: orderedDataStoreOperations,
|
|
711
|
+
},
|
|
712
|
+
},
|
|
713
|
+
},
|
|
714
|
+
{
|
|
715
|
+
displayName: 'Operation ID',
|
|
716
|
+
name: 'operationId',
|
|
717
|
+
type: 'string',
|
|
718
|
+
default: '',
|
|
719
|
+
required: true,
|
|
720
|
+
description: 'The memory store flush operation ID',
|
|
721
|
+
displayOptions: {
|
|
722
|
+
show: {
|
|
723
|
+
resource: ['storage'],
|
|
724
|
+
operation: ['get_memory_store_flush_operation'],
|
|
725
|
+
},
|
|
726
|
+
},
|
|
727
|
+
},
|
|
728
|
+
{
|
|
729
|
+
displayName: 'Query Parameters',
|
|
730
|
+
name: 'data_store_list_query',
|
|
731
|
+
default: {},
|
|
732
|
+
type: 'collection',
|
|
733
|
+
description: "The request's query parameters",
|
|
734
|
+
displayOptions: {
|
|
735
|
+
show: {
|
|
736
|
+
resource: ['storage'],
|
|
737
|
+
operation: [
|
|
738
|
+
'list_data_stores',
|
|
739
|
+
'list_data_store_entries',
|
|
740
|
+
'list_scoped_data_store_entries',
|
|
741
|
+
],
|
|
742
|
+
},
|
|
743
|
+
},
|
|
744
|
+
options: [
|
|
745
|
+
{
|
|
746
|
+
displayName: 'Filter',
|
|
747
|
+
name: 'filter',
|
|
748
|
+
type: 'string',
|
|
749
|
+
default: '',
|
|
750
|
+
description: 'Filter expression for returned resources',
|
|
751
|
+
},
|
|
752
|
+
{
|
|
753
|
+
displayName: 'Max Page Size',
|
|
754
|
+
name: 'maxPageSize',
|
|
755
|
+
type: 'number',
|
|
756
|
+
default: 10,
|
|
757
|
+
description: 'Maximum number of results to return',
|
|
758
|
+
},
|
|
759
|
+
{
|
|
760
|
+
displayName: 'Page Token',
|
|
761
|
+
name: 'pageToken',
|
|
762
|
+
type: 'string',
|
|
763
|
+
typeOptions: {
|
|
764
|
+
password: true,
|
|
765
|
+
},
|
|
766
|
+
default: '',
|
|
767
|
+
description: 'Page token from a previous response',
|
|
768
|
+
},
|
|
769
|
+
{
|
|
770
|
+
displayName: 'Show Deleted',
|
|
771
|
+
name: 'showDeleted',
|
|
772
|
+
type: 'boolean',
|
|
773
|
+
default: false,
|
|
774
|
+
description: 'Whether to include deleted resources',
|
|
775
|
+
},
|
|
776
|
+
],
|
|
777
|
+
},
|
|
778
|
+
{
|
|
779
|
+
displayName: 'Query Parameters',
|
|
780
|
+
name: 'data_store_revision_query',
|
|
781
|
+
default: {},
|
|
782
|
+
type: 'collection',
|
|
783
|
+
description: "The request's query parameters",
|
|
784
|
+
displayOptions: {
|
|
785
|
+
show: {
|
|
786
|
+
resource: ['storage'],
|
|
787
|
+
operation: ['list_data_store_entry_revisions', 'list_scoped_data_store_entry_revisions'],
|
|
788
|
+
},
|
|
789
|
+
},
|
|
790
|
+
options: [
|
|
791
|
+
{
|
|
792
|
+
displayName: 'Filter',
|
|
793
|
+
name: 'filter',
|
|
794
|
+
type: 'string',
|
|
795
|
+
default: '',
|
|
796
|
+
description: 'Filter expression for returned revisions',
|
|
797
|
+
},
|
|
798
|
+
{
|
|
799
|
+
displayName: 'Max Page Size',
|
|
800
|
+
name: 'maxPageSize',
|
|
801
|
+
type: 'number',
|
|
802
|
+
default: 10,
|
|
803
|
+
description: 'Maximum number of revisions to return',
|
|
804
|
+
},
|
|
805
|
+
{
|
|
806
|
+
displayName: 'Page Token',
|
|
807
|
+
name: 'pageToken',
|
|
808
|
+
type: 'string',
|
|
809
|
+
typeOptions: {
|
|
810
|
+
password: true,
|
|
811
|
+
},
|
|
812
|
+
default: '',
|
|
813
|
+
description: 'Page token from a previous response',
|
|
814
|
+
},
|
|
815
|
+
],
|
|
816
|
+
},
|
|
817
|
+
{
|
|
818
|
+
displayName: 'Query Parameters',
|
|
819
|
+
name: 'data_store_create_query',
|
|
820
|
+
default: {},
|
|
821
|
+
type: 'collection',
|
|
822
|
+
description: "The request's query parameters",
|
|
823
|
+
displayOptions: {
|
|
824
|
+
show: {
|
|
825
|
+
resource: ['storage'],
|
|
826
|
+
operation: ['create_data_store_entry', 'create_scoped_data_store_entry'],
|
|
827
|
+
},
|
|
828
|
+
},
|
|
829
|
+
options: [
|
|
830
|
+
{
|
|
831
|
+
displayName: 'ID',
|
|
832
|
+
name: 'id',
|
|
833
|
+
type: 'string',
|
|
834
|
+
default: '',
|
|
835
|
+
description: 'The entry ID to create',
|
|
836
|
+
},
|
|
837
|
+
],
|
|
838
|
+
},
|
|
839
|
+
{
|
|
840
|
+
displayName: 'Update Fields',
|
|
841
|
+
name: 'data_store_update_query',
|
|
842
|
+
default: {},
|
|
843
|
+
type: 'collection',
|
|
844
|
+
description: "The request's query parameters",
|
|
845
|
+
displayOptions: {
|
|
846
|
+
show: {
|
|
847
|
+
resource: ['storage'],
|
|
848
|
+
operation: ['update_data_store_entry', 'update_scoped_data_store_entry'],
|
|
849
|
+
},
|
|
850
|
+
},
|
|
851
|
+
options: [
|
|
852
|
+
{
|
|
853
|
+
displayName: 'Allow Missing',
|
|
854
|
+
name: 'allowMissing',
|
|
855
|
+
type: 'boolean',
|
|
856
|
+
default: false,
|
|
857
|
+
description: 'Whether to create the entry if it does not exist',
|
|
858
|
+
},
|
|
859
|
+
],
|
|
860
|
+
},
|
|
861
|
+
{
|
|
862
|
+
displayName: 'Data Store Entry',
|
|
863
|
+
name: 'dataStoreEntryJson',
|
|
864
|
+
type: 'json',
|
|
865
|
+
default: '{"value":{}}',
|
|
866
|
+
required: true,
|
|
867
|
+
description: 'The data store entry JSON body',
|
|
868
|
+
displayOptions: {
|
|
869
|
+
show: {
|
|
870
|
+
resource: ['storage'],
|
|
871
|
+
operation: [
|
|
872
|
+
'create_data_store_entry',
|
|
873
|
+
'update_data_store_entry',
|
|
874
|
+
'create_scoped_data_store_entry',
|
|
875
|
+
'update_scoped_data_store_entry',
|
|
876
|
+
],
|
|
877
|
+
},
|
|
878
|
+
},
|
|
879
|
+
},
|
|
880
|
+
{
|
|
881
|
+
displayName: 'Increment Data Store Entry',
|
|
882
|
+
name: 'incrementDataStoreEntryJson',
|
|
883
|
+
type: 'json',
|
|
884
|
+
default: '{"amount":1}',
|
|
885
|
+
required: true,
|
|
886
|
+
description: 'The increment data store entry JSON body',
|
|
887
|
+
displayOptions: {
|
|
888
|
+
show: {
|
|
889
|
+
resource: ['storage'],
|
|
890
|
+
operation: ['increment_data_store_entry', 'increment_scoped_data_store_entry'],
|
|
891
|
+
},
|
|
892
|
+
},
|
|
893
|
+
},
|
|
894
|
+
{
|
|
895
|
+
displayName: 'Memory Store Queue Item',
|
|
896
|
+
name: 'memoryStoreQueueItemJson',
|
|
897
|
+
type: 'json',
|
|
898
|
+
default: '{"data":{},"priority":0,"ttl":"30s"}',
|
|
899
|
+
required: true,
|
|
900
|
+
description: 'The memory store queue item JSON body',
|
|
901
|
+
displayOptions: {
|
|
902
|
+
show: {
|
|
903
|
+
resource: ['storage'],
|
|
904
|
+
operation: ['create_memory_store_queue_item'],
|
|
905
|
+
},
|
|
906
|
+
},
|
|
907
|
+
},
|
|
908
|
+
{
|
|
909
|
+
displayName: 'Query Parameters',
|
|
910
|
+
name: 'memory_store_queue_read_query',
|
|
911
|
+
default: {},
|
|
912
|
+
type: 'collection',
|
|
913
|
+
description: "The request's query parameters",
|
|
914
|
+
displayOptions: {
|
|
915
|
+
show: {
|
|
916
|
+
resource: ['storage'],
|
|
917
|
+
operation: ['read_memory_store_queue_items'],
|
|
918
|
+
},
|
|
919
|
+
},
|
|
920
|
+
options: [
|
|
921
|
+
{
|
|
922
|
+
displayName: 'All Or Nothing',
|
|
923
|
+
name: 'allOrNothing',
|
|
924
|
+
type: 'boolean',
|
|
925
|
+
default: false,
|
|
926
|
+
description: 'Whether the read should fail unless all requested items are available',
|
|
927
|
+
},
|
|
928
|
+
{
|
|
929
|
+
displayName: 'Count',
|
|
930
|
+
name: 'count',
|
|
931
|
+
type: 'number',
|
|
932
|
+
default: 1,
|
|
933
|
+
description: 'Number of queue items to read',
|
|
934
|
+
},
|
|
935
|
+
{
|
|
936
|
+
displayName: 'Invisibility Window',
|
|
937
|
+
name: 'invisibilityWindow',
|
|
938
|
+
type: 'string',
|
|
939
|
+
default: '30s',
|
|
940
|
+
description: 'How long read items stay invisible before discard',
|
|
941
|
+
},
|
|
942
|
+
],
|
|
943
|
+
},
|
|
944
|
+
{
|
|
945
|
+
displayName: 'Discard Memory Store Queue Items',
|
|
946
|
+
name: 'discardMemoryStoreQueueItemsJson',
|
|
947
|
+
type: 'json',
|
|
948
|
+
default: '{"readId":""}',
|
|
949
|
+
required: true,
|
|
950
|
+
description: 'The discard memory store queue items JSON body',
|
|
951
|
+
displayOptions: {
|
|
952
|
+
show: {
|
|
953
|
+
resource: ['storage'],
|
|
954
|
+
operation: ['discard_memory_store_queue_items'],
|
|
955
|
+
},
|
|
956
|
+
},
|
|
957
|
+
},
|
|
958
|
+
{
|
|
959
|
+
displayName: 'Query Parameters',
|
|
960
|
+
name: 'memory_store_sorted_map_list_query',
|
|
961
|
+
default: {},
|
|
962
|
+
type: 'collection',
|
|
963
|
+
description: "The request's query parameters",
|
|
964
|
+
displayOptions: {
|
|
965
|
+
show: {
|
|
966
|
+
resource: ['storage'],
|
|
967
|
+
operation: ['list_memory_store_sorted_map_items'],
|
|
968
|
+
},
|
|
969
|
+
},
|
|
970
|
+
options: [
|
|
971
|
+
{
|
|
972
|
+
displayName: 'Filter',
|
|
973
|
+
name: 'filter',
|
|
974
|
+
type: 'string',
|
|
975
|
+
default: '',
|
|
976
|
+
description: 'Filter expression for returned sorted map items',
|
|
977
|
+
},
|
|
978
|
+
{
|
|
979
|
+
displayName: 'Max Page Size',
|
|
980
|
+
name: 'maxPageSize',
|
|
981
|
+
type: 'number',
|
|
982
|
+
default: 10,
|
|
983
|
+
description: 'Maximum number of sorted map items to return',
|
|
984
|
+
},
|
|
985
|
+
{
|
|
986
|
+
displayName: 'Order By',
|
|
987
|
+
name: 'orderBy',
|
|
988
|
+
type: 'string',
|
|
989
|
+
default: '',
|
|
990
|
+
description: 'Sort order for returned sorted map items',
|
|
991
|
+
},
|
|
992
|
+
{
|
|
993
|
+
displayName: 'Page Token',
|
|
994
|
+
name: 'pageToken',
|
|
995
|
+
type: 'string',
|
|
996
|
+
typeOptions: {
|
|
997
|
+
password: true,
|
|
998
|
+
},
|
|
999
|
+
default: '',
|
|
1000
|
+
description: 'Page token from a previous response',
|
|
1001
|
+
},
|
|
1002
|
+
],
|
|
1003
|
+
},
|
|
1004
|
+
{
|
|
1005
|
+
displayName: 'Query Parameters',
|
|
1006
|
+
name: 'memory_store_sorted_map_create_query',
|
|
1007
|
+
default: {},
|
|
1008
|
+
type: 'collection',
|
|
1009
|
+
description: "The request's query parameters",
|
|
1010
|
+
displayOptions: {
|
|
1011
|
+
show: {
|
|
1012
|
+
resource: ['storage'],
|
|
1013
|
+
operation: ['create_memory_store_sorted_map_item'],
|
|
1014
|
+
},
|
|
1015
|
+
},
|
|
1016
|
+
options: [
|
|
1017
|
+
{
|
|
1018
|
+
displayName: 'ID',
|
|
1019
|
+
name: 'id',
|
|
1020
|
+
type: 'string',
|
|
1021
|
+
default: '',
|
|
1022
|
+
description: 'The sorted map item ID to create',
|
|
1023
|
+
},
|
|
1024
|
+
],
|
|
1025
|
+
},
|
|
1026
|
+
{
|
|
1027
|
+
displayName: 'Update Fields',
|
|
1028
|
+
name: 'memory_store_sorted_map_update_query',
|
|
1029
|
+
default: {},
|
|
1030
|
+
type: 'collection',
|
|
1031
|
+
description: "The request's query parameters",
|
|
1032
|
+
displayOptions: {
|
|
1033
|
+
show: {
|
|
1034
|
+
resource: ['storage'],
|
|
1035
|
+
operation: ['update_memory_store_sorted_map_item'],
|
|
1036
|
+
},
|
|
1037
|
+
},
|
|
1038
|
+
options: [
|
|
1039
|
+
{
|
|
1040
|
+
displayName: 'Allow Missing',
|
|
1041
|
+
name: 'allowMissing',
|
|
1042
|
+
type: 'boolean',
|
|
1043
|
+
default: false,
|
|
1044
|
+
description: 'Whether to create the sorted map item if it does not exist',
|
|
1045
|
+
},
|
|
1046
|
+
],
|
|
1047
|
+
},
|
|
1048
|
+
{
|
|
1049
|
+
displayName: 'Memory Store Sorted Map Item',
|
|
1050
|
+
name: 'memoryStoreSortedMapItemJson',
|
|
1051
|
+
type: 'json',
|
|
1052
|
+
default: '{"value":{},"ttl":"30s"}',
|
|
1053
|
+
required: true,
|
|
1054
|
+
description: 'The memory store sorted map item JSON body',
|
|
1055
|
+
displayOptions: {
|
|
1056
|
+
show: {
|
|
1057
|
+
resource: ['storage'],
|
|
1058
|
+
operation: ['create_memory_store_sorted_map_item', 'update_memory_store_sorted_map_item'],
|
|
1059
|
+
},
|
|
1060
|
+
},
|
|
1061
|
+
},
|
|
1062
|
+
{
|
|
1063
|
+
displayName: 'Query Parameters',
|
|
1064
|
+
name: 'ordered_data_store_list_query',
|
|
1065
|
+
default: {},
|
|
1066
|
+
type: 'collection',
|
|
1067
|
+
description: "The request's query parameters",
|
|
1068
|
+
displayOptions: {
|
|
1069
|
+
show: {
|
|
1070
|
+
resource: ['storage'],
|
|
1071
|
+
operation: ['list_ordered_data_store_entries'],
|
|
1072
|
+
},
|
|
1073
|
+
},
|
|
1074
|
+
options: [
|
|
1075
|
+
{
|
|
1076
|
+
displayName: 'Filter',
|
|
1077
|
+
name: 'filter',
|
|
1078
|
+
type: 'string',
|
|
1079
|
+
default: '',
|
|
1080
|
+
description: 'Filter expression for returned ordered data store entries',
|
|
1081
|
+
},
|
|
1082
|
+
{
|
|
1083
|
+
displayName: 'Max Page Size',
|
|
1084
|
+
name: 'maxPageSize',
|
|
1085
|
+
type: 'number',
|
|
1086
|
+
default: 10,
|
|
1087
|
+
description: 'Maximum number of ordered data store entries to return',
|
|
1088
|
+
},
|
|
1089
|
+
{
|
|
1090
|
+
displayName: 'Order By',
|
|
1091
|
+
name: 'orderBy',
|
|
1092
|
+
type: 'string',
|
|
1093
|
+
default: '',
|
|
1094
|
+
description: 'Sort order for returned ordered data store entries',
|
|
1095
|
+
},
|
|
1096
|
+
{
|
|
1097
|
+
displayName: 'Page Token',
|
|
1098
|
+
name: 'pageToken',
|
|
1099
|
+
type: 'string',
|
|
1100
|
+
typeOptions: {
|
|
1101
|
+
password: true,
|
|
1102
|
+
},
|
|
1103
|
+
default: '',
|
|
1104
|
+
description: 'Page token from a previous response',
|
|
1105
|
+
},
|
|
1106
|
+
],
|
|
1107
|
+
},
|
|
1108
|
+
{
|
|
1109
|
+
displayName: 'Query Parameters',
|
|
1110
|
+
name: 'ordered_data_store_create_query',
|
|
1111
|
+
default: {},
|
|
1112
|
+
type: 'collection',
|
|
1113
|
+
description: "The request's query parameters",
|
|
1114
|
+
displayOptions: {
|
|
1115
|
+
show: {
|
|
1116
|
+
resource: ['storage'],
|
|
1117
|
+
operation: ['create_ordered_data_store_entry'],
|
|
1118
|
+
},
|
|
1119
|
+
},
|
|
1120
|
+
options: [
|
|
1121
|
+
{
|
|
1122
|
+
displayName: 'ID',
|
|
1123
|
+
name: 'id',
|
|
1124
|
+
type: 'string',
|
|
1125
|
+
default: '',
|
|
1126
|
+
description: 'The ordered data store entry ID to create',
|
|
1127
|
+
},
|
|
1128
|
+
],
|
|
1129
|
+
},
|
|
1130
|
+
{
|
|
1131
|
+
displayName: 'Update Fields',
|
|
1132
|
+
name: 'ordered_data_store_update_query',
|
|
1133
|
+
default: {},
|
|
1134
|
+
type: 'collection',
|
|
1135
|
+
description: "The request's query parameters",
|
|
1136
|
+
displayOptions: {
|
|
1137
|
+
show: {
|
|
1138
|
+
resource: ['storage'],
|
|
1139
|
+
operation: ['update_ordered_data_store_entry'],
|
|
1140
|
+
},
|
|
1141
|
+
},
|
|
1142
|
+
options: [
|
|
1143
|
+
{
|
|
1144
|
+
displayName: 'Allow Missing',
|
|
1145
|
+
name: 'allowMissing',
|
|
1146
|
+
type: 'boolean',
|
|
1147
|
+
default: false,
|
|
1148
|
+
description: 'Whether to create the ordered data store entry if it does not exist',
|
|
1149
|
+
},
|
|
1150
|
+
],
|
|
1151
|
+
},
|
|
1152
|
+
{
|
|
1153
|
+
displayName: 'Ordered Data Store Entry',
|
|
1154
|
+
name: 'orderedDataStoreEntryJson',
|
|
1155
|
+
type: 'json',
|
|
1156
|
+
default: '{"value":0}',
|
|
1157
|
+
required: true,
|
|
1158
|
+
description: 'The ordered data store entry JSON body',
|
|
1159
|
+
displayOptions: {
|
|
1160
|
+
show: {
|
|
1161
|
+
resource: ['storage'],
|
|
1162
|
+
operation: ['create_ordered_data_store_entry', 'update_ordered_data_store_entry'],
|
|
1163
|
+
},
|
|
1164
|
+
},
|
|
1165
|
+
},
|
|
1166
|
+
{
|
|
1167
|
+
displayName: 'Increment Ordered Data Store Entry',
|
|
1168
|
+
name: 'incrementOrderedDataStoreEntryJson',
|
|
1169
|
+
type: 'json',
|
|
1170
|
+
default: '{"amount":1}',
|
|
1171
|
+
required: true,
|
|
1172
|
+
description: 'The increment ordered data store entry JSON body',
|
|
1173
|
+
displayOptions: {
|
|
1174
|
+
show: {
|
|
1175
|
+
resource: ['storage'],
|
|
1176
|
+
operation: ['increment_ordered_data_store_entry'],
|
|
1177
|
+
},
|
|
1178
|
+
},
|
|
1179
|
+
},
|
|
1180
|
+
];
|
|
1181
|
+
//# sourceMappingURL=StorageDescription.js.map
|