dynamo-command-builder 0.1.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/LICENSE +21 -0
- package/README.md +10 -0
- package/dist/index.d.mts +138 -0
- package/dist/index.d.ts +138 -0
- package/dist/index.js +992 -0
- package/dist/index.js.map +1 -0
- package/dist/index.mjs +975 -0
- package/dist/index.mjs.map +1 -0
- package/package.json +76 -0
package/dist/index.mjs
ADDED
|
@@ -0,0 +1,975 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
|
|
3
|
+
// src/utils/query-request/comparator.ts
|
|
4
|
+
function createKeyConditionExpression(queryRequest) {
|
|
5
|
+
const { sKey, skValue2, skComparator } = queryRequest;
|
|
6
|
+
let keyConditionExpression = "#pk = :pk";
|
|
7
|
+
if (!sKey && !skValue2) return keyConditionExpression;
|
|
8
|
+
switch (getOperatorSymbolByKey(skComparator ?? "=")) {
|
|
9
|
+
case "<":
|
|
10
|
+
keyConditionExpression += " AND #sk < :sk";
|
|
11
|
+
break;
|
|
12
|
+
case ">":
|
|
13
|
+
keyConditionExpression += " AND #sk > :sk";
|
|
14
|
+
break;
|
|
15
|
+
case "<=":
|
|
16
|
+
keyConditionExpression += " AND #sk <= :sk";
|
|
17
|
+
break;
|
|
18
|
+
case ">=":
|
|
19
|
+
keyConditionExpression += " AND #sk >= :sk";
|
|
20
|
+
break;
|
|
21
|
+
case "BEGINS_WITH":
|
|
22
|
+
if (!skValue2) throw new Error("BEGINS_WITH operation requires skValue2.");
|
|
23
|
+
keyConditionExpression += ` AND begins_with(#sk, :skValue2)`;
|
|
24
|
+
break;
|
|
25
|
+
case "BETWEEN":
|
|
26
|
+
if (!sKey || !skValue2) throw new Error("BETWEEN operation requires both sk and skValue2.");
|
|
27
|
+
keyConditionExpression += " AND #sk BETWEEN :sk AND :skValue2";
|
|
28
|
+
break;
|
|
29
|
+
default:
|
|
30
|
+
keyConditionExpression += " AND #sk = :sk";
|
|
31
|
+
break;
|
|
32
|
+
}
|
|
33
|
+
return keyConditionExpression;
|
|
34
|
+
}
|
|
35
|
+
function getOperatorSymbolByKey(operation) {
|
|
36
|
+
switch (operation.toUpperCase()) {
|
|
37
|
+
case "BETWEEN":
|
|
38
|
+
return "BETWEEN";
|
|
39
|
+
case "BEGINS_WITH":
|
|
40
|
+
return "BEGINS_WITH";
|
|
41
|
+
case "GREATER_THAN":
|
|
42
|
+
case ">":
|
|
43
|
+
return ">";
|
|
44
|
+
case "LESS_THAN":
|
|
45
|
+
case "<":
|
|
46
|
+
return "<";
|
|
47
|
+
case "GREATER_THAN_OR_EQUAL":
|
|
48
|
+
case ">=":
|
|
49
|
+
return ">=";
|
|
50
|
+
case "LESS_THAN_OR_EQUAL":
|
|
51
|
+
case "<=":
|
|
52
|
+
return "<=";
|
|
53
|
+
case "EQUAL":
|
|
54
|
+
case "=":
|
|
55
|
+
return "=";
|
|
56
|
+
default:
|
|
57
|
+
throw new Error(`Invalid operation key: ${operation}`);
|
|
58
|
+
}
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
// src/utils/dynamo-value-parse.ts
|
|
62
|
+
function parseDynamoKeyValue(key, keyType) {
|
|
63
|
+
switch (keyType) {
|
|
64
|
+
case "S":
|
|
65
|
+
return key;
|
|
66
|
+
case "N":
|
|
67
|
+
return Number(key);
|
|
68
|
+
case "BOOL":
|
|
69
|
+
return key.toLowerCase() === "true";
|
|
70
|
+
case "NULL":
|
|
71
|
+
return null;
|
|
72
|
+
case "M":
|
|
73
|
+
try {
|
|
74
|
+
return JSON.parse(key);
|
|
75
|
+
} catch {
|
|
76
|
+
throw new Error("Invalid JSON format for partitionKeyType M (Map)");
|
|
77
|
+
}
|
|
78
|
+
case "L":
|
|
79
|
+
try {
|
|
80
|
+
return JSON.parse(key);
|
|
81
|
+
} catch {
|
|
82
|
+
throw new Error("Invalid JSON format for partitionKeyType L (List)");
|
|
83
|
+
}
|
|
84
|
+
case "SS":
|
|
85
|
+
return key.split(",").map((item) => item.trim());
|
|
86
|
+
case "NS":
|
|
87
|
+
return key.split(",").map((item) => Number(item.trim())).filter((num) => !isNaN(num));
|
|
88
|
+
case "BS":
|
|
89
|
+
return key.split(",").map((item) => Buffer.from(item.trim(), "base64"));
|
|
90
|
+
default:
|
|
91
|
+
throw new Error(`Unsupported partitionKeyType: ${keyType}`);
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
// src/utils/expression-attribute-names.ts
|
|
96
|
+
function extractExpAttributeNamesFromExpression(expression) {
|
|
97
|
+
const result = {};
|
|
98
|
+
for (const raw of expression.split(",")) {
|
|
99
|
+
const attr = raw.trim();
|
|
100
|
+
if (attr.startsWith("#")) {
|
|
101
|
+
result[attr] = attr.slice(1);
|
|
102
|
+
}
|
|
103
|
+
}
|
|
104
|
+
return result;
|
|
105
|
+
}
|
|
106
|
+
function extractExpAttributeNamesFromUpdateExp(expression) {
|
|
107
|
+
const result = {};
|
|
108
|
+
const body = expression.replace(/^\s*SET\s+/i, "").trim();
|
|
109
|
+
if (!body) return result;
|
|
110
|
+
const assignments = body.split(",");
|
|
111
|
+
for (const assignment of assignments) {
|
|
112
|
+
const leftSide = assignment.split("=")[0]?.trim();
|
|
113
|
+
if (!leftSide || !leftSide.startsWith("#")) continue;
|
|
114
|
+
result[leftSide] = leftSide.slice(1);
|
|
115
|
+
}
|
|
116
|
+
return result;
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
// src/utils/reserved-keywords.ts
|
|
120
|
+
var RESERVED_KEYWORDS_SET = /* @__PURE__ */ new Set([
|
|
121
|
+
"ABORT",
|
|
122
|
+
"ABSOLUTE",
|
|
123
|
+
"ACTION",
|
|
124
|
+
"ADD",
|
|
125
|
+
"AFTER",
|
|
126
|
+
"AGENT",
|
|
127
|
+
"AGGREGATE",
|
|
128
|
+
"ALL",
|
|
129
|
+
"ALLOCATE",
|
|
130
|
+
"ALTER",
|
|
131
|
+
"ANALYZE",
|
|
132
|
+
"AND",
|
|
133
|
+
"ANY",
|
|
134
|
+
"ARCHIVE",
|
|
135
|
+
"ARE",
|
|
136
|
+
"ARRAY",
|
|
137
|
+
"AS",
|
|
138
|
+
"ASC",
|
|
139
|
+
"ASCII",
|
|
140
|
+
"ASENSITIVE",
|
|
141
|
+
"ASSERTION",
|
|
142
|
+
"ASYMMETRIC",
|
|
143
|
+
"AT",
|
|
144
|
+
"ATOMIC",
|
|
145
|
+
"ATTACH",
|
|
146
|
+
"ATTRIBUTE",
|
|
147
|
+
"AUTH",
|
|
148
|
+
"AUTHORIZATION",
|
|
149
|
+
"AUTHORIZE",
|
|
150
|
+
"AUTO",
|
|
151
|
+
"AVG",
|
|
152
|
+
"BACK",
|
|
153
|
+
"BACKUP",
|
|
154
|
+
"BASE",
|
|
155
|
+
"BATCH",
|
|
156
|
+
"BEFORE",
|
|
157
|
+
"BEGIN",
|
|
158
|
+
"BETWEEN",
|
|
159
|
+
"BIGINT",
|
|
160
|
+
"BINARY",
|
|
161
|
+
"BIT",
|
|
162
|
+
"BLOB",
|
|
163
|
+
"BLOCK",
|
|
164
|
+
"BOOLEAN",
|
|
165
|
+
"BOTH",
|
|
166
|
+
"BREADTH",
|
|
167
|
+
"BUCKET",
|
|
168
|
+
"BULK",
|
|
169
|
+
"BY",
|
|
170
|
+
"BYTE",
|
|
171
|
+
"CALL",
|
|
172
|
+
"CALLED",
|
|
173
|
+
"CALLING",
|
|
174
|
+
"CAPACITY",
|
|
175
|
+
"CASCADE",
|
|
176
|
+
"CASCADED",
|
|
177
|
+
"CASE",
|
|
178
|
+
"CAST",
|
|
179
|
+
"CATALOG",
|
|
180
|
+
"CHAR",
|
|
181
|
+
"CHARACTER",
|
|
182
|
+
"CHECK",
|
|
183
|
+
"CLASS",
|
|
184
|
+
"CLOB",
|
|
185
|
+
"CLOSE",
|
|
186
|
+
"CLUSTER",
|
|
187
|
+
"CLUSTERED",
|
|
188
|
+
"CLUSTERING",
|
|
189
|
+
"CLUSTERS",
|
|
190
|
+
"COALESCE",
|
|
191
|
+
"COLLATE",
|
|
192
|
+
"COLLATION",
|
|
193
|
+
"COLLECTION",
|
|
194
|
+
"COLUMN",
|
|
195
|
+
"COLUMNS",
|
|
196
|
+
"COMBINE",
|
|
197
|
+
"COMMENT",
|
|
198
|
+
"COMMIT",
|
|
199
|
+
"COMPACT",
|
|
200
|
+
"COMPILE",
|
|
201
|
+
"COMPRESS",
|
|
202
|
+
"CONDITION",
|
|
203
|
+
"CONFLICT",
|
|
204
|
+
"CONNECT",
|
|
205
|
+
"CONNECTION",
|
|
206
|
+
"CONSISTENCY",
|
|
207
|
+
"CONSISTENT",
|
|
208
|
+
"CONSTRAINT",
|
|
209
|
+
"CONSTRUCTOR",
|
|
210
|
+
"CONSUMED",
|
|
211
|
+
"CONTINUE",
|
|
212
|
+
"CONVERT",
|
|
213
|
+
"COPY",
|
|
214
|
+
"CORRESPONDING",
|
|
215
|
+
"COUNT",
|
|
216
|
+
"COUNTER",
|
|
217
|
+
"CREATE",
|
|
218
|
+
"CROSS",
|
|
219
|
+
"CSV",
|
|
220
|
+
"CUBE",
|
|
221
|
+
"CURRENT",
|
|
222
|
+
"CURSOR",
|
|
223
|
+
"CYCLE",
|
|
224
|
+
"DATA",
|
|
225
|
+
"DATABASE",
|
|
226
|
+
"DATE",
|
|
227
|
+
"DATETIME",
|
|
228
|
+
"DAY",
|
|
229
|
+
"DEALLOCATE",
|
|
230
|
+
"DEC",
|
|
231
|
+
"DECIMAL",
|
|
232
|
+
"DECLARE",
|
|
233
|
+
"DEFAULT",
|
|
234
|
+
"DEFERRABLE",
|
|
235
|
+
"DEFERRED",
|
|
236
|
+
"DEFINE",
|
|
237
|
+
"DEFINED",
|
|
238
|
+
"DEFINITION",
|
|
239
|
+
"DELETE",
|
|
240
|
+
"DELIMITED",
|
|
241
|
+
"DEPTH",
|
|
242
|
+
"DEREF",
|
|
243
|
+
"DESC",
|
|
244
|
+
"DESCRIBE",
|
|
245
|
+
"DESCRIPTOR",
|
|
246
|
+
"DETACH",
|
|
247
|
+
"DETERMINISTIC",
|
|
248
|
+
"DIAGNOSTICS",
|
|
249
|
+
"DIRECTORIES",
|
|
250
|
+
"DISABLE",
|
|
251
|
+
"DISCONNECT",
|
|
252
|
+
"DISTINCT",
|
|
253
|
+
"DISTRIBUTE",
|
|
254
|
+
"DO",
|
|
255
|
+
"DOMAIN",
|
|
256
|
+
"DOUBLE",
|
|
257
|
+
"DROP",
|
|
258
|
+
"DUMP",
|
|
259
|
+
"DURATION",
|
|
260
|
+
"DYNAMIC",
|
|
261
|
+
"EACH",
|
|
262
|
+
"ELEMENT",
|
|
263
|
+
"ELSE",
|
|
264
|
+
"ELSEIF",
|
|
265
|
+
"EMPTY",
|
|
266
|
+
"ENABLE",
|
|
267
|
+
"END",
|
|
268
|
+
"EQUAL",
|
|
269
|
+
"EQUALS",
|
|
270
|
+
"ERROR",
|
|
271
|
+
"ESCAPE",
|
|
272
|
+
"ESCAPED",
|
|
273
|
+
"EVAL",
|
|
274
|
+
"EVALUATE",
|
|
275
|
+
"EXCEEDED",
|
|
276
|
+
"EXCEPT",
|
|
277
|
+
"EXCEPTIONS",
|
|
278
|
+
"EXCLUSIVE",
|
|
279
|
+
"EXEC",
|
|
280
|
+
"EXECUTE",
|
|
281
|
+
"EXISTS",
|
|
282
|
+
"EXIT",
|
|
283
|
+
"EXPLAIN",
|
|
284
|
+
"EXPLODE",
|
|
285
|
+
"EXPORT",
|
|
286
|
+
"EXPRESSION",
|
|
287
|
+
"EXTENDED",
|
|
288
|
+
"EXTERNAL",
|
|
289
|
+
"EXTRACT",
|
|
290
|
+
"FAIL",
|
|
291
|
+
"FALSE",
|
|
292
|
+
"FAMILY",
|
|
293
|
+
"FETCH",
|
|
294
|
+
"FIELDS",
|
|
295
|
+
"FILE",
|
|
296
|
+
"FILTER",
|
|
297
|
+
"FILTERING",
|
|
298
|
+
"FINAL",
|
|
299
|
+
"FINISH",
|
|
300
|
+
"FIRST",
|
|
301
|
+
"FIXED",
|
|
302
|
+
"FLATTERN",
|
|
303
|
+
"FLOAT",
|
|
304
|
+
"FOR",
|
|
305
|
+
"FORCE",
|
|
306
|
+
"FOREIGN",
|
|
307
|
+
"FORMAT",
|
|
308
|
+
"FORWARD",
|
|
309
|
+
"FOUND",
|
|
310
|
+
"FREE",
|
|
311
|
+
"FROM",
|
|
312
|
+
"FULL",
|
|
313
|
+
"FUNCTION",
|
|
314
|
+
"FUNCTIONS",
|
|
315
|
+
"GENERAL",
|
|
316
|
+
"GENERATE",
|
|
317
|
+
"GET",
|
|
318
|
+
"GLOB",
|
|
319
|
+
"GLOBAL",
|
|
320
|
+
"GO",
|
|
321
|
+
"GOTO",
|
|
322
|
+
"GRANT",
|
|
323
|
+
"GROUP",
|
|
324
|
+
"GROUPING",
|
|
325
|
+
"HANDLER",
|
|
326
|
+
"HASH",
|
|
327
|
+
"HAVE",
|
|
328
|
+
"HAVING",
|
|
329
|
+
"HEAP",
|
|
330
|
+
"HIDDEN",
|
|
331
|
+
"HOLD",
|
|
332
|
+
"HOUR",
|
|
333
|
+
"IDENTIFIED",
|
|
334
|
+
"IDENTITY",
|
|
335
|
+
"IF",
|
|
336
|
+
"IGNORE",
|
|
337
|
+
"IMMEDIATE",
|
|
338
|
+
"IMPORT",
|
|
339
|
+
"IN",
|
|
340
|
+
"INCLUDING",
|
|
341
|
+
"INCLUSIVE",
|
|
342
|
+
"INCREMENT",
|
|
343
|
+
"INDEX",
|
|
344
|
+
"INDEXED",
|
|
345
|
+
"INDEXES",
|
|
346
|
+
"INET",
|
|
347
|
+
"INF",
|
|
348
|
+
"INFINITE",
|
|
349
|
+
"INITIALLY",
|
|
350
|
+
"INLINE",
|
|
351
|
+
"INNER",
|
|
352
|
+
"INNTER",
|
|
353
|
+
"INPUT",
|
|
354
|
+
"INSENSITIVE",
|
|
355
|
+
"INSERT",
|
|
356
|
+
"INSTEAD",
|
|
357
|
+
"INT",
|
|
358
|
+
"INTEGER",
|
|
359
|
+
"INTERSECT",
|
|
360
|
+
"INTERVAL",
|
|
361
|
+
"INTO",
|
|
362
|
+
"INVALIDATE",
|
|
363
|
+
"IS",
|
|
364
|
+
"ISOLATION",
|
|
365
|
+
"ITEM",
|
|
366
|
+
"ITEMS",
|
|
367
|
+
"ITERATE",
|
|
368
|
+
"JOIN",
|
|
369
|
+
"KEY",
|
|
370
|
+
"KEYS",
|
|
371
|
+
"LAG",
|
|
372
|
+
"LANGUAGE",
|
|
373
|
+
"LARGE",
|
|
374
|
+
"LAST",
|
|
375
|
+
"LATERAL",
|
|
376
|
+
"LEAD",
|
|
377
|
+
"LEADING",
|
|
378
|
+
"LEAVE",
|
|
379
|
+
"LEFT",
|
|
380
|
+
"LEVEL",
|
|
381
|
+
"LIKE",
|
|
382
|
+
"LIMIT",
|
|
383
|
+
"LIMITED",
|
|
384
|
+
"LINES",
|
|
385
|
+
"LIST",
|
|
386
|
+
"LOAD",
|
|
387
|
+
"LOCAL",
|
|
388
|
+
"LOCALTIME",
|
|
389
|
+
"LOCALTIMESTAMP",
|
|
390
|
+
"LOCATION",
|
|
391
|
+
"LOCATOR",
|
|
392
|
+
"LOCK",
|
|
393
|
+
"LOCKS",
|
|
394
|
+
"LOG",
|
|
395
|
+
"LOGED",
|
|
396
|
+
"LONG",
|
|
397
|
+
"LOOP",
|
|
398
|
+
"LOW",
|
|
399
|
+
"MAP",
|
|
400
|
+
"MATCH",
|
|
401
|
+
"MATERIALIZED",
|
|
402
|
+
"MAX",
|
|
403
|
+
"MAXLEN",
|
|
404
|
+
"MEMBER",
|
|
405
|
+
"MERGE",
|
|
406
|
+
"METHOD",
|
|
407
|
+
"MIN",
|
|
408
|
+
"MINUS",
|
|
409
|
+
"MINUTE",
|
|
410
|
+
"MISSING",
|
|
411
|
+
"MOD",
|
|
412
|
+
"MODE",
|
|
413
|
+
"MODIFIES",
|
|
414
|
+
"MODIFY",
|
|
415
|
+
"MODULE",
|
|
416
|
+
"MONTH",
|
|
417
|
+
"MULTI",
|
|
418
|
+
"MULTISET",
|
|
419
|
+
"NAME",
|
|
420
|
+
"NAMES",
|
|
421
|
+
"NATIONAL",
|
|
422
|
+
"NATURAL",
|
|
423
|
+
"NCHAR",
|
|
424
|
+
"NCLOB",
|
|
425
|
+
"NEW",
|
|
426
|
+
"NEXT",
|
|
427
|
+
"NO",
|
|
428
|
+
"NONE",
|
|
429
|
+
"NOT",
|
|
430
|
+
"NULL",
|
|
431
|
+
"NULLIF",
|
|
432
|
+
"NUMBER",
|
|
433
|
+
"NUMERIC",
|
|
434
|
+
"OBJECT",
|
|
435
|
+
"OF",
|
|
436
|
+
"OFFLINE",
|
|
437
|
+
"OFFSET",
|
|
438
|
+
"OLD",
|
|
439
|
+
"ON",
|
|
440
|
+
"ONLINE",
|
|
441
|
+
"ONLY",
|
|
442
|
+
"OPAQUE",
|
|
443
|
+
"OPEN",
|
|
444
|
+
"OPERATOR",
|
|
445
|
+
"OPTION",
|
|
446
|
+
"OR",
|
|
447
|
+
"ORDER",
|
|
448
|
+
"ORDINALITY",
|
|
449
|
+
"OUT",
|
|
450
|
+
"OUTER",
|
|
451
|
+
"OUTPUT",
|
|
452
|
+
"OVER",
|
|
453
|
+
"OVERLAPS",
|
|
454
|
+
"OVERRIDE",
|
|
455
|
+
"PARTITION",
|
|
456
|
+
"PARTITIONED",
|
|
457
|
+
"PARTITIONS",
|
|
458
|
+
"PATH",
|
|
459
|
+
"PERCENT",
|
|
460
|
+
"PERCENTILE",
|
|
461
|
+
"PERMISSION",
|
|
462
|
+
"PERMISSIONS",
|
|
463
|
+
"PIPE",
|
|
464
|
+
"PIPELINED",
|
|
465
|
+
"PLAN",
|
|
466
|
+
"POOL",
|
|
467
|
+
"POSITION",
|
|
468
|
+
"PRECISION",
|
|
469
|
+
"PREPARE",
|
|
470
|
+
"PRESERVE",
|
|
471
|
+
"PRIMARY",
|
|
472
|
+
"PRIOR",
|
|
473
|
+
"PRIVATE",
|
|
474
|
+
"PRIVILEGES",
|
|
475
|
+
"PROCEDURE",
|
|
476
|
+
"PROCESSED",
|
|
477
|
+
"PROJECT",
|
|
478
|
+
"PROJECTION",
|
|
479
|
+
"PROPERTY",
|
|
480
|
+
"PROVISIONING",
|
|
481
|
+
"PUBLIC",
|
|
482
|
+
"PUT",
|
|
483
|
+
"QUERY",
|
|
484
|
+
"QUIT",
|
|
485
|
+
"QUORUM",
|
|
486
|
+
"RAISE",
|
|
487
|
+
"RANGE",
|
|
488
|
+
"RANK",
|
|
489
|
+
"RAW",
|
|
490
|
+
"READ",
|
|
491
|
+
"READS",
|
|
492
|
+
"REAL",
|
|
493
|
+
"REBUILD",
|
|
494
|
+
"RECORD",
|
|
495
|
+
"RECURSIVE",
|
|
496
|
+
"REDUCE",
|
|
497
|
+
"REF",
|
|
498
|
+
"REFERENCE",
|
|
499
|
+
"REFERENCES",
|
|
500
|
+
"REFERENCING",
|
|
501
|
+
"REGEXP",
|
|
502
|
+
"REGION",
|
|
503
|
+
"REINDEX",
|
|
504
|
+
"RELATIVE",
|
|
505
|
+
"RELEASE",
|
|
506
|
+
"REMA",
|
|
507
|
+
"REMAINDER",
|
|
508
|
+
"RENAME",
|
|
509
|
+
"REPEAT",
|
|
510
|
+
"REPLACE",
|
|
511
|
+
"REQUEST",
|
|
512
|
+
"RESET",
|
|
513
|
+
"RESIGNAL",
|
|
514
|
+
"RESOURCE",
|
|
515
|
+
"RESPONSE",
|
|
516
|
+
"RESTORE",
|
|
517
|
+
"RESTRICT",
|
|
518
|
+
"RESULT",
|
|
519
|
+
"RETURN",
|
|
520
|
+
"RETURNING",
|
|
521
|
+
"REVEAL",
|
|
522
|
+
"REVERSE",
|
|
523
|
+
"REVOKE",
|
|
524
|
+
"RIGHT",
|
|
525
|
+
"ROLE",
|
|
526
|
+
"ROLES",
|
|
527
|
+
"ROLLBACK",
|
|
528
|
+
"ROLLUP",
|
|
529
|
+
"ROUTINE",
|
|
530
|
+
"ROW",
|
|
531
|
+
"ROWS",
|
|
532
|
+
"RULE",
|
|
533
|
+
"RULES",
|
|
534
|
+
"SAMPLE",
|
|
535
|
+
"SATISFIES",
|
|
536
|
+
"SAVE",
|
|
537
|
+
"SAVEPOINT",
|
|
538
|
+
"SCAN",
|
|
539
|
+
"SCHEMA",
|
|
540
|
+
"SCOPE",
|
|
541
|
+
"SCROLL",
|
|
542
|
+
"SEARCH",
|
|
543
|
+
"SECOND",
|
|
544
|
+
"SECTION",
|
|
545
|
+
"SEGMENT",
|
|
546
|
+
"SEGMENTS",
|
|
547
|
+
"SELECT",
|
|
548
|
+
"SELF",
|
|
549
|
+
"SEMI",
|
|
550
|
+
"SENSITIVE",
|
|
551
|
+
"SEPARATE",
|
|
552
|
+
"SEQUENCE",
|
|
553
|
+
"SERIALIZABLE",
|
|
554
|
+
"SESSION",
|
|
555
|
+
"SET",
|
|
556
|
+
"SETS",
|
|
557
|
+
"SHARD",
|
|
558
|
+
"SHARE",
|
|
559
|
+
"SHARED",
|
|
560
|
+
"SHORT",
|
|
561
|
+
"SHOW",
|
|
562
|
+
"SIGNAL",
|
|
563
|
+
"SIMILAR",
|
|
564
|
+
"SIZE",
|
|
565
|
+
"SKEWED",
|
|
566
|
+
"SMALLINT",
|
|
567
|
+
"SNAPSHOT",
|
|
568
|
+
"SOME",
|
|
569
|
+
"SOURCE",
|
|
570
|
+
"SPACE",
|
|
571
|
+
"SPLIT",
|
|
572
|
+
"SQL",
|
|
573
|
+
"SQLCODE",
|
|
574
|
+
"SQLERROR",
|
|
575
|
+
"SQLEXCEPTION",
|
|
576
|
+
"SQLSTATE",
|
|
577
|
+
"SQLWARNING",
|
|
578
|
+
"START",
|
|
579
|
+
"STATE",
|
|
580
|
+
"STATIC",
|
|
581
|
+
"STATUS",
|
|
582
|
+
"STORAGE",
|
|
583
|
+
"STORE",
|
|
584
|
+
"STORED",
|
|
585
|
+
"STREAM",
|
|
586
|
+
"STRING",
|
|
587
|
+
"STRUCT",
|
|
588
|
+
"STYLE",
|
|
589
|
+
"SUB",
|
|
590
|
+
"SUBMULTISET",
|
|
591
|
+
"SUBPARTITION",
|
|
592
|
+
"SUBSTRING",
|
|
593
|
+
"SUBTYPE",
|
|
594
|
+
"SUM",
|
|
595
|
+
"SUPER",
|
|
596
|
+
"SYMMETRIC",
|
|
597
|
+
"SYNONYM",
|
|
598
|
+
"SYSTEM",
|
|
599
|
+
"TABLE",
|
|
600
|
+
"TABLESAMPLE",
|
|
601
|
+
"TEMP",
|
|
602
|
+
"TEMPORARY",
|
|
603
|
+
"TERMINATED",
|
|
604
|
+
"TEXT",
|
|
605
|
+
"THAN",
|
|
606
|
+
"THEN",
|
|
607
|
+
"THROUGHPUT",
|
|
608
|
+
"TIME",
|
|
609
|
+
"TIMESTAMP",
|
|
610
|
+
"TIMEZONE",
|
|
611
|
+
"TINYINT",
|
|
612
|
+
"TO",
|
|
613
|
+
"TOKEN",
|
|
614
|
+
"TOTAL",
|
|
615
|
+
"TOUCH",
|
|
616
|
+
"TRAILING",
|
|
617
|
+
"TRAN",
|
|
618
|
+
"TRANSACTION",
|
|
619
|
+
"TRANSFORM",
|
|
620
|
+
"TRANSLATE",
|
|
621
|
+
"TRANSLATION",
|
|
622
|
+
"TREAT",
|
|
623
|
+
"TRIGGER",
|
|
624
|
+
"TRIM",
|
|
625
|
+
"TRUE",
|
|
626
|
+
"TRUNCATE",
|
|
627
|
+
"TTL",
|
|
628
|
+
"TUPLE",
|
|
629
|
+
"TYPE",
|
|
630
|
+
"UNDER",
|
|
631
|
+
"UNDO",
|
|
632
|
+
"UNION",
|
|
633
|
+
"UNIQUE",
|
|
634
|
+
"UNIT",
|
|
635
|
+
"UNKNOWN",
|
|
636
|
+
"UNLOGGED",
|
|
637
|
+
"UNNEST",
|
|
638
|
+
"UNPROCESSED",
|
|
639
|
+
"UNSIGNED",
|
|
640
|
+
"UNTIL",
|
|
641
|
+
"UPDATE",
|
|
642
|
+
"UPPER",
|
|
643
|
+
"URL",
|
|
644
|
+
"USAGE",
|
|
645
|
+
"USE",
|
|
646
|
+
"USING",
|
|
647
|
+
"UUID",
|
|
648
|
+
"VACUUM",
|
|
649
|
+
"VALUE",
|
|
650
|
+
"VALUED",
|
|
651
|
+
"VALUES",
|
|
652
|
+
"VARCHAR",
|
|
653
|
+
"VARIABLE",
|
|
654
|
+
"VARIANCE",
|
|
655
|
+
"VARINT",
|
|
656
|
+
"VARYING",
|
|
657
|
+
"VIEW",
|
|
658
|
+
"VIEWS",
|
|
659
|
+
"VIRTUAL",
|
|
660
|
+
"VOID",
|
|
661
|
+
"WAIT",
|
|
662
|
+
"WHEN",
|
|
663
|
+
"WHENEVER",
|
|
664
|
+
"WHERE",
|
|
665
|
+
"WHILE",
|
|
666
|
+
"WINDOW",
|
|
667
|
+
"WITH",
|
|
668
|
+
"WITHIN",
|
|
669
|
+
"WITHOUT",
|
|
670
|
+
"WORK",
|
|
671
|
+
"WRAPPED",
|
|
672
|
+
"WRITE",
|
|
673
|
+
"YEAR",
|
|
674
|
+
"ZONE"
|
|
675
|
+
]);
|
|
676
|
+
var UPDATE_RESERVED_REGEX = new RegExp(`\\b(?:${[...RESERVED_KEYWORDS_SET].join("|")})\\b(?=\\s*=)`, "gi");
|
|
677
|
+
function replaceReservedKeywordsFromUpdateExp(updateExpression) {
|
|
678
|
+
return updateExpression.replace(UPDATE_RESERVED_REGEX, (match) => `#${match}`);
|
|
679
|
+
}
|
|
680
|
+
function replaceReservedKeywordsFromProjection(projection) {
|
|
681
|
+
return projection.split(",").map((item) => {
|
|
682
|
+
const trimmed = item.trim();
|
|
683
|
+
if (!trimmed) return trimmed;
|
|
684
|
+
return RESERVED_KEYWORDS_SET.has(trimmed.toUpperCase()) ? `#${trimmed}` : trimmed;
|
|
685
|
+
}).join(", ");
|
|
686
|
+
}
|
|
687
|
+
|
|
688
|
+
// src/command/build-get-command.ts
|
|
689
|
+
function buildGetCommandInput(input) {
|
|
690
|
+
const {
|
|
691
|
+
tableName: TableName,
|
|
692
|
+
// The name of the DynamoDB table
|
|
693
|
+
key: Key,
|
|
694
|
+
// The key of the item to retrieve
|
|
695
|
+
projectionExpression,
|
|
696
|
+
// Optional: Specifies attributes to retrieve
|
|
697
|
+
expressionAttributeNames: extraExpressionAttributesNames,
|
|
698
|
+
// Additional expression attribute names
|
|
699
|
+
consistentRead: ConsistentRead,
|
|
700
|
+
// Optional: Specifies whether to use strongly consistent reads
|
|
701
|
+
returnConsumedCapacity: ReturnConsumedCapacity
|
|
702
|
+
// Optional: Determines whether to return consumed capacity
|
|
703
|
+
} = input;
|
|
704
|
+
const ProjectionExpression = projectionExpression ? replaceReservedKeywordsFromProjection(projectionExpression) : void 0;
|
|
705
|
+
const commandInput = {
|
|
706
|
+
TableName,
|
|
707
|
+
Key,
|
|
708
|
+
ProjectionExpression,
|
|
709
|
+
ConsistentRead,
|
|
710
|
+
ReturnConsumedCapacity
|
|
711
|
+
};
|
|
712
|
+
const expressionAttributeNames = {
|
|
713
|
+
...ProjectionExpression ? extractExpAttributeNamesFromExpression(ProjectionExpression) : {},
|
|
714
|
+
...extraExpressionAttributesNames ?? {}
|
|
715
|
+
};
|
|
716
|
+
if (Object.keys(expressionAttributeNames).length > 0) {
|
|
717
|
+
commandInput.ExpressionAttributeNames = expressionAttributeNames;
|
|
718
|
+
}
|
|
719
|
+
return commandInput;
|
|
720
|
+
}
|
|
721
|
+
|
|
722
|
+
// src/command/build-put-command.ts
|
|
723
|
+
function buildPutCommandInput(input) {
|
|
724
|
+
const {
|
|
725
|
+
tableName,
|
|
726
|
+
item,
|
|
727
|
+
conditionExpression,
|
|
728
|
+
expressionAttributeNames,
|
|
729
|
+
expressionAttributeValues,
|
|
730
|
+
returnValues = "NONE",
|
|
731
|
+
returnConsumedCapacity,
|
|
732
|
+
returnItemCollectionMetrics
|
|
733
|
+
} = input;
|
|
734
|
+
const commandInput = {
|
|
735
|
+
TableName: tableName,
|
|
736
|
+
Item: item,
|
|
737
|
+
ConditionExpression: conditionExpression,
|
|
738
|
+
ReturnValues: returnValues,
|
|
739
|
+
ReturnConsumedCapacity: returnConsumedCapacity,
|
|
740
|
+
ReturnItemCollectionMetrics: returnItemCollectionMetrics
|
|
741
|
+
};
|
|
742
|
+
const hasCondition = !!conditionExpression;
|
|
743
|
+
const hasProvidedNames = !!expressionAttributeNames && Object.keys(expressionAttributeNames).length > 0;
|
|
744
|
+
if (hasCondition || hasProvidedNames) {
|
|
745
|
+
const generatedNames = hasCondition ? extractExpAttributeNamesFromExpression(conditionExpression) : {};
|
|
746
|
+
const mergedNames = hasProvidedNames ? { ...generatedNames, ...expressionAttributeNames } : generatedNames;
|
|
747
|
+
if (Object.keys(mergedNames).length > 0) {
|
|
748
|
+
commandInput.ExpressionAttributeNames = mergedNames;
|
|
749
|
+
}
|
|
750
|
+
}
|
|
751
|
+
if (expressionAttributeValues && Object.keys(expressionAttributeValues).length > 0) {
|
|
752
|
+
commandInput.ExpressionAttributeValues = expressionAttributeValues;
|
|
753
|
+
}
|
|
754
|
+
return commandInput;
|
|
755
|
+
}
|
|
756
|
+
|
|
757
|
+
// src/command/build-query-command.ts
|
|
758
|
+
function buildQueryCommandInput(input) {
|
|
759
|
+
const { queryRequest } = input;
|
|
760
|
+
const KeyConditionExpression = createKeyConditionExpression(queryRequest);
|
|
761
|
+
const ProjectionExpression = input.projectionExpression ? replaceReservedKeywordsFromProjection(input.projectionExpression) : void 0;
|
|
762
|
+
const ExpressionAttributeNames = {
|
|
763
|
+
"#pk": queryRequest.pKeyProp,
|
|
764
|
+
...queryRequest.sKeyProp && { "#sk": queryRequest.sKeyProp },
|
|
765
|
+
...ProjectionExpression && extractExpAttributeNamesFromExpression(ProjectionExpression),
|
|
766
|
+
...input.extraExpAttributeNames || {}
|
|
767
|
+
};
|
|
768
|
+
const ExpressionAttributeValues = {
|
|
769
|
+
":pk": parseDynamoKeyValue(queryRequest.pKey, queryRequest.pKeyType),
|
|
770
|
+
...queryRequest.sKey && {
|
|
771
|
+
":sk": parseDynamoKeyValue(queryRequest.sKey, queryRequest.sKeyType ?? `S`)
|
|
772
|
+
},
|
|
773
|
+
...queryRequest.skValue2 && {
|
|
774
|
+
":skValue2": parseDynamoKeyValue(queryRequest.skValue2, queryRequest.sKeyType ?? `S`)
|
|
775
|
+
},
|
|
776
|
+
...input.extraExpAttributeValues || {}
|
|
777
|
+
};
|
|
778
|
+
const commandInput = {
|
|
779
|
+
TableName: input.tableName,
|
|
780
|
+
IndexName: queryRequest.indexName,
|
|
781
|
+
KeyConditionExpression,
|
|
782
|
+
FilterExpression: input.filterExpression,
|
|
783
|
+
ExpressionAttributeNames,
|
|
784
|
+
ExpressionAttributeValues,
|
|
785
|
+
ProjectionExpression,
|
|
786
|
+
ScanIndexForward: queryRequest.sorting !== void 0 ? queryRequest.sorting.toUpperCase() === "ASC" : input.scanIndexForward,
|
|
787
|
+
ReturnConsumedCapacity: input.returnConsumedCapacity,
|
|
788
|
+
ExclusiveStartKey: queryRequest.lastEvaluatedKey,
|
|
789
|
+
Limit: queryRequest.limit
|
|
790
|
+
};
|
|
791
|
+
return commandInput;
|
|
792
|
+
}
|
|
793
|
+
|
|
794
|
+
// src/command/build-update-command.ts
|
|
795
|
+
function buildUpdateCommandInput(input) {
|
|
796
|
+
const commandInput = {
|
|
797
|
+
TableName: input.tableName,
|
|
798
|
+
Key: input.key,
|
|
799
|
+
ConditionExpression: input.conditionExpression,
|
|
800
|
+
ReturnValues: input.returnValues ?? "NONE",
|
|
801
|
+
ReturnConsumedCapacity: input.returnConsumedCapacity,
|
|
802
|
+
ReturnItemCollectionMetrics: input.returnItemCollectionMetrics
|
|
803
|
+
};
|
|
804
|
+
const names = {};
|
|
805
|
+
const values = {};
|
|
806
|
+
if (input.expressionAttributeNames) {
|
|
807
|
+
for (const key in input.expressionAttributeNames) {
|
|
808
|
+
names[key] = input.expressionAttributeNames[key];
|
|
809
|
+
}
|
|
810
|
+
}
|
|
811
|
+
if (input.extraExpAttributeNames) {
|
|
812
|
+
for (const key in input.extraExpAttributeNames) {
|
|
813
|
+
names[key] = input.extraExpAttributeNames[key];
|
|
814
|
+
}
|
|
815
|
+
}
|
|
816
|
+
if (input.expressionAttributeValues) {
|
|
817
|
+
for (const key in input.expressionAttributeValues) {
|
|
818
|
+
values[key] = input.expressionAttributeValues[key];
|
|
819
|
+
}
|
|
820
|
+
}
|
|
821
|
+
if (input.extraExpAttributeValues) {
|
|
822
|
+
for (const key in input.extraExpAttributeValues) {
|
|
823
|
+
values[key] = input.extraExpAttributeValues[key];
|
|
824
|
+
}
|
|
825
|
+
}
|
|
826
|
+
let updateExpression = input.updateExpression;
|
|
827
|
+
if (updateExpression) {
|
|
828
|
+
if (Object.keys(names).length > 0) {
|
|
829
|
+
commandInput.ExpressionAttributeNames = names;
|
|
830
|
+
}
|
|
831
|
+
if (Object.keys(values).length > 0) {
|
|
832
|
+
commandInput.ExpressionAttributeValues = values;
|
|
833
|
+
}
|
|
834
|
+
commandInput.UpdateExpression = updateExpression;
|
|
835
|
+
return commandInput;
|
|
836
|
+
}
|
|
837
|
+
const item = input.item;
|
|
838
|
+
if (!item || Object.keys(item).length === 0) {
|
|
839
|
+
throw new Error("Either updateExpression or item with at least one field must be provided.");
|
|
840
|
+
}
|
|
841
|
+
const updateParts = [];
|
|
842
|
+
const itemRecord = item;
|
|
843
|
+
for (const field in itemRecord) {
|
|
844
|
+
const value = itemRecord[field];
|
|
845
|
+
let valueKey = `:${field}`;
|
|
846
|
+
if (values[valueKey] !== void 0) {
|
|
847
|
+
let counter = 1;
|
|
848
|
+
let candidate;
|
|
849
|
+
do {
|
|
850
|
+
candidate = `:${field}_update_${counter++}`;
|
|
851
|
+
} while (values[candidate] !== void 0);
|
|
852
|
+
valueKey = candidate;
|
|
853
|
+
}
|
|
854
|
+
updateParts.push(`${field} = ${valueKey}`);
|
|
855
|
+
values[valueKey] = value;
|
|
856
|
+
}
|
|
857
|
+
const rawExpression = `SET ${updateParts.join(", ")}`;
|
|
858
|
+
updateExpression = replaceReservedKeywordsFromUpdateExp(rawExpression);
|
|
859
|
+
const autoNames = extractExpAttributeNamesFromUpdateExp(updateExpression);
|
|
860
|
+
for (const key in autoNames) {
|
|
861
|
+
if (!(key in names)) {
|
|
862
|
+
names[key] = autoNames[key];
|
|
863
|
+
}
|
|
864
|
+
}
|
|
865
|
+
if (Object.keys(names).length > 0) {
|
|
866
|
+
commandInput.ExpressionAttributeNames = names;
|
|
867
|
+
}
|
|
868
|
+
if (Object.keys(values).length > 0) {
|
|
869
|
+
commandInput.ExpressionAttributeValues = values;
|
|
870
|
+
}
|
|
871
|
+
commandInput.UpdateExpression = updateExpression;
|
|
872
|
+
return commandInput;
|
|
873
|
+
}
|
|
874
|
+
var dynamoQueryRequestSch = z.object({
|
|
875
|
+
pKey: z.string(),
|
|
876
|
+
pKeyType: z.string(),
|
|
877
|
+
pKeyProp: z.string(),
|
|
878
|
+
sKey: z.string().optional(),
|
|
879
|
+
sKeyType: z.string().optional(),
|
|
880
|
+
sKeyProp: z.string().optional(),
|
|
881
|
+
skValue2: z.string().optional(),
|
|
882
|
+
skValue2Type: z.string().optional(),
|
|
883
|
+
skComparator: z.string().optional(),
|
|
884
|
+
indexName: z.string().optional(),
|
|
885
|
+
limit: z.number().optional(),
|
|
886
|
+
lastEvaluatedKey: z.record(z.string(), z.unknown()).optional(),
|
|
887
|
+
sorting: z.string().optional()
|
|
888
|
+
}).superRefine((data, ctx) => {
|
|
889
|
+
if (data.skComparator) {
|
|
890
|
+
if (!data.sKey) {
|
|
891
|
+
ctx.addIssue({
|
|
892
|
+
path: ["sKey"],
|
|
893
|
+
message: "sKey is required when skComparator is present",
|
|
894
|
+
code: "invalid_type",
|
|
895
|
+
expected: "string",
|
|
896
|
+
received: typeof data.sKey
|
|
897
|
+
});
|
|
898
|
+
}
|
|
899
|
+
if (!data.sKeyProp) {
|
|
900
|
+
ctx.addIssue({
|
|
901
|
+
path: ["sKeyProp"],
|
|
902
|
+
message: "sKeyProp is required when skComparator is present",
|
|
903
|
+
code: "invalid_type",
|
|
904
|
+
expected: "string",
|
|
905
|
+
received: typeof data.sKeyProp
|
|
906
|
+
});
|
|
907
|
+
}
|
|
908
|
+
if (!data.sKeyType) {
|
|
909
|
+
ctx.addIssue({
|
|
910
|
+
path: ["sKeyType"],
|
|
911
|
+
message: "sKeyType is required when skComparator is present",
|
|
912
|
+
code: "invalid_type",
|
|
913
|
+
expected: "string",
|
|
914
|
+
received: typeof data.sKeyType
|
|
915
|
+
});
|
|
916
|
+
}
|
|
917
|
+
}
|
|
918
|
+
});
|
|
919
|
+
|
|
920
|
+
// src/types/command.types.ts
|
|
921
|
+
var returnConsumedCapacityOptionsSchema = z.enum(["INDEXES", "TOTAL", "NONE"]);
|
|
922
|
+
var returnItemCollectionMetricsOptionsSchema = z.enum(["SIZE", "NONE"]);
|
|
923
|
+
var customGetCommandInputSchema = z.object({
|
|
924
|
+
tableName: z.string(),
|
|
925
|
+
key: z.record(z.string(), z.unknown()),
|
|
926
|
+
projectionExpression: z.string().optional(),
|
|
927
|
+
expressionAttributeNames: z.record(z.string(), z.string()).optional(),
|
|
928
|
+
consistentRead: z.boolean().optional(),
|
|
929
|
+
returnConsumedCapacity: returnConsumedCapacityOptionsSchema.optional()
|
|
930
|
+
});
|
|
931
|
+
var customQueryCommandInputSchema = z.object({
|
|
932
|
+
tableName: z.string(),
|
|
933
|
+
queryRequest: dynamoQueryRequestSch,
|
|
934
|
+
keyConditionExpression: z.string().optional(),
|
|
935
|
+
filterExpression: z.string().optional(),
|
|
936
|
+
expressionAttributeNames: z.record(z.string(), z.string()).optional(),
|
|
937
|
+
expressionAttributeValues: z.record(z.string(), z.unknown()).optional(),
|
|
938
|
+
extraExpAttributeNames: z.record(z.string(), z.string()).optional(),
|
|
939
|
+
extraExpAttributeValues: z.record(z.string(), z.unknown()).optional(),
|
|
940
|
+
projectionExpression: z.string().optional(),
|
|
941
|
+
scanIndexForward: z.boolean().optional(),
|
|
942
|
+
returnConsumedCapacity: returnConsumedCapacityOptionsSchema.optional()
|
|
943
|
+
});
|
|
944
|
+
var customPutCommandInputSchema = z.object({
|
|
945
|
+
tableName: z.string(),
|
|
946
|
+
item: z.record(z.string(), z.unknown()),
|
|
947
|
+
conditionExpression: z.string().optional(),
|
|
948
|
+
expressionAttributeNames: z.record(z.string(), z.string()).optional(),
|
|
949
|
+
expressionAttributeValues: z.record(z.string(), z.unknown()).optional(),
|
|
950
|
+
returnValues: z.enum(["NONE", "ALL_OLD", "UPDATED_OLD", "ALL_NEW", "UPDATED_NEW"]).optional(),
|
|
951
|
+
returnConsumedCapacity: returnConsumedCapacityOptionsSchema.optional(),
|
|
952
|
+
returnItemCollectionMetrics: returnItemCollectionMetricsOptionsSchema.optional()
|
|
953
|
+
});
|
|
954
|
+
var customUpdateCommandInputSchema = z.object({
|
|
955
|
+
tableName: z.string(),
|
|
956
|
+
key: z.record(z.string(), z.unknown()),
|
|
957
|
+
item: z.record(z.string(), z.unknown()).optional(),
|
|
958
|
+
updateExpression: z.string().optional(),
|
|
959
|
+
conditionExpression: z.string().optional(),
|
|
960
|
+
expressionAttributeNames: z.record(z.string(), z.string()).optional(),
|
|
961
|
+
// Overwrite ExpressionAttributeNames
|
|
962
|
+
expressionAttributeValues: z.record(z.string(), z.unknown()).optional(),
|
|
963
|
+
// Overwrite ExpressionAttributeValues
|
|
964
|
+
extraExpAttributeNames: z.record(z.string(), z.string()).optional(),
|
|
965
|
+
// Add ExpressionAttributeNames without overwriting existing ones
|
|
966
|
+
extraExpAttributeValues: z.record(z.string(), z.unknown()).optional(),
|
|
967
|
+
// Add ExpressionAttributeValues without overwriting existing ones
|
|
968
|
+
returnValues: z.enum(["NONE", "ALL_OLD", "UPDATED_OLD", "ALL_NEW", "UPDATED_NEW"]).optional(),
|
|
969
|
+
returnConsumedCapacity: returnConsumedCapacityOptionsSchema.optional(),
|
|
970
|
+
returnItemCollectionMetrics: returnItemCollectionMetricsOptionsSchema.optional()
|
|
971
|
+
});
|
|
972
|
+
|
|
973
|
+
export { RESERVED_KEYWORDS_SET, buildGetCommandInput, buildPutCommandInput, buildQueryCommandInput, buildUpdateCommandInput, createKeyConditionExpression, customGetCommandInputSchema, customPutCommandInputSchema, customQueryCommandInputSchema, customUpdateCommandInputSchema, dynamoQueryRequestSch, extractExpAttributeNamesFromExpression, extractExpAttributeNamesFromUpdateExp, parseDynamoKeyValue, replaceReservedKeywordsFromProjection, replaceReservedKeywordsFromUpdateExp };
|
|
974
|
+
//# sourceMappingURL=index.mjs.map
|
|
975
|
+
//# sourceMappingURL=index.mjs.map
|