dynamo-command-builder 0.1.7 → 0.2.2

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { GetCommandInput, PutCommandInput, QueryCommandInput, UpdateCommandInput } from '@aws-sdk/lib-dynamodb';
+import { GetCommandInput, PutCommandInput, QueryCommandInput, ScanCommandInput, UpdateCommandInput } from '@aws-sdk/lib-dynamodb';
 import { z } from 'zod';
 
 declare const dynamoAttrTypeSch: z.ZodEnum<{
@@ -41,11 +41,16 @@ type DynamoQueryRequest = {
     skComparator?: DynamoComparator;
     indexName?: string;
     limit?: number;
-    lastEvaluatedKey?: Record<string, unknown>;
+    lastEvaluatedKey?: Record<string, unknown> | undefined;
     sorting?: 'ASC' | 'DESC';
 };
 declare const dynamoQueryRequestSch: z.ZodType<DynamoQueryRequest>;
+type DynamoQueryReq = z.infer<typeof dynamoQueryRequestSch>;
 
+declare const genericRecordSch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+type GenericRecord = z.infer<typeof genericRecordSch>;
+declare const stringRecordSch: z.ZodRecord<z.ZodString, z.ZodString>;
+type StringRecord = z.infer<typeof stringRecordSch>;
 declare const customGetCommandInputSchema: z.ZodObject<{
     tableName: z.ZodString;
     key: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -129,13 +134,151 @@ declare const customUpdateCommandInputSchema: z.ZodObject<{
     }>>;
 }, z.core.$strip>;
 type CustomUpdateCommandInput = z.infer<typeof customUpdateCommandInputSchema>;
+declare const customScanCommandInputSch: z.ZodObject<{
+    tableName: z.ZodString;
+    indexName: z.ZodOptional<z.ZodString>;
+    filtersAttributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            S: "S";
+            N: "N";
+            BOOL: "BOOL";
+            NULL: "NULL";
+            SS: "SS";
+            NS: "NS";
+        }>;
+        condition: z.ZodEnum<{
+            BETWEEN: "BETWEEN";
+            BEGINS_WITH: "BEGINS_WITH";
+            EQUAL_TO: "EQUAL_TO";
+            NOT_EQUAL_TO: "NOT_EQUAL_TO";
+            LESS_THAN: "LESS_THAN";
+            LESS_THAN_OR_EQUAL_TO: "LESS_THAN_OR_EQUAL_TO";
+            GREATER_THAN: "GREATER_THAN";
+            GREATER_THAN_OR_EQUAL_TO: "GREATER_THAN_OR_EQUAL_TO";
+            EXISTS: "EXISTS";
+            NOT_EXISTS: "NOT_EXISTS";
+            CONTAINS: "CONTAINS";
+            NOT_CONTAINS: "NOT_CONTAINS";
+        }>;
+        value: z.ZodOptional<z.ZodString>;
+        value2: z.ZodOptional<z.ZodString>;
+        values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    filterExpression: z.ZodOptional<z.ZodString>;
+    projectionExpression: z.ZodOptional<z.ZodString>;
+    expressionAttributeNames: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    expressionAttributeValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    extraExpAttributeNames: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    extraExpAttributeValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    exclusiveStartKey: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    consistentRead: z.ZodOptional<z.ZodBoolean>;
+    segment: z.ZodOptional<z.ZodNumber>;
+    totalSegments: z.ZodOptional<z.ZodNumber>;
+    returnConsumedCapacity: z.ZodOptional<z.ZodEnum<{
+        INDEXES: "INDEXES";
+        TOTAL: "TOTAL";
+        NONE: "NONE";
+    }>>;
+    returnItemCollectionMetrics: z.ZodOptional<z.ZodEnum<{
+        NONE: "NONE";
+        SIZE: "SIZE";
+    }>>;
+}, z.core.$strip>;
+type CustomScanCommandInput = z.infer<typeof customScanCommandInputSch>;
 
 declare function buildGetCommandInput(input: CustomGetCommandInput): GetCommandInput;
 
+declare const dynamoFilterValueTypeSch: z.ZodEnum<{
+    S: "S";
+    N: "N";
+    BOOL: "BOOL";
+    NULL: "NULL";
+    SS: "SS";
+    NS: "NS";
+}>;
+type DynamoFilterValueType = z.infer<typeof dynamoFilterValueTypeSch>;
+declare const dynamoFilterConditionSch: z.ZodEnum<{
+    BETWEEN: "BETWEEN";
+    BEGINS_WITH: "BEGINS_WITH";
+    EQUAL_TO: "EQUAL_TO";
+    NOT_EQUAL_TO: "NOT_EQUAL_TO";
+    LESS_THAN: "LESS_THAN";
+    LESS_THAN_OR_EQUAL_TO: "LESS_THAN_OR_EQUAL_TO";
+    GREATER_THAN: "GREATER_THAN";
+    GREATER_THAN_OR_EQUAL_TO: "GREATER_THAN_OR_EQUAL_TO";
+    EXISTS: "EXISTS";
+    NOT_EXISTS: "NOT_EXISTS";
+    CONTAINS: "CONTAINS";
+    NOT_CONTAINS: "NOT_CONTAINS";
+}>;
+type DynamoFilterCondition = z.infer<typeof dynamoFilterConditionSch>;
+declare const dynamoFilterSch: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        S: "S";
+        N: "N";
+        BOOL: "BOOL";
+        NULL: "NULL";
+        SS: "SS";
+        NS: "NS";
+    }>;
+    condition: z.ZodEnum<{
+        BETWEEN: "BETWEEN";
+        BEGINS_WITH: "BEGINS_WITH";
+        EQUAL_TO: "EQUAL_TO";
+        NOT_EQUAL_TO: "NOT_EQUAL_TO";
+        LESS_THAN: "LESS_THAN";
+        LESS_THAN_OR_EQUAL_TO: "LESS_THAN_OR_EQUAL_TO";
+        GREATER_THAN: "GREATER_THAN";
+        GREATER_THAN_OR_EQUAL_TO: "GREATER_THAN_OR_EQUAL_TO";
+        EXISTS: "EXISTS";
+        NOT_EXISTS: "NOT_EXISTS";
+        CONTAINS: "CONTAINS";
+        NOT_CONTAINS: "NOT_CONTAINS";
+    }>;
+    value: z.ZodOptional<z.ZodString>;
+    value2: z.ZodOptional<z.ZodString>;
+    values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type DynamoFilter = z.infer<typeof dynamoFilterSch>;
+declare const dynamoFiltersInputSch: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        S: "S";
+        N: "N";
+        BOOL: "BOOL";
+        NULL: "NULL";
+        SS: "SS";
+        NS: "NS";
+    }>;
+    condition: z.ZodEnum<{
+        BETWEEN: "BETWEEN";
+        BEGINS_WITH: "BEGINS_WITH";
+        EQUAL_TO: "EQUAL_TO";
+        NOT_EQUAL_TO: "NOT_EQUAL_TO";
+        LESS_THAN: "LESS_THAN";
+        LESS_THAN_OR_EQUAL_TO: "LESS_THAN_OR_EQUAL_TO";
+        GREATER_THAN: "GREATER_THAN";
+        GREATER_THAN_OR_EQUAL_TO: "GREATER_THAN_OR_EQUAL_TO";
+        EXISTS: "EXISTS";
+        NOT_EXISTS: "NOT_EXISTS";
+        CONTAINS: "CONTAINS";
+        NOT_CONTAINS: "NOT_CONTAINS";
+    }>;
+    value: z.ZodOptional<z.ZodString>;
+    value2: z.ZodOptional<z.ZodString>;
+    values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>;
+type DynamoFiltersInput = z.infer<typeof dynamoFiltersInputSch>;
+
 declare function buildPutCommandInput(input: CustomPutCommandInput): PutCommandInput;
 
 declare function buildQueryCommandInput(input: CustomQueryCommandInput): QueryCommandInput;
 
+declare function buildScanCommandInput(custom: CustomScanCommandInput): ScanCommandInput;
+
 declare function buildUpdateCommandInput(input: CustomUpdateCommandInput): UpdateCommandInput;
 
 declare function createKeyConditionExpression(queryRequest: DynamoQueryRequest): string;
@@ -155,9 +298,19 @@ declare const RESERVED_KEYWORDS_SET: Set<string>;
 declare function replaceReservedKeywordsFromUpdateExp(updateExpression: string): string;
 declare function replaceReservedKeywordsFromProjection(projection: string): string;
 
+declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+
 declare class QueryParseError extends Error {
     statusCode: number;
     constructor(message: string, statusCode?: number);
 }
 
-export { type CustomGetCommandInput, type CustomPutCommandInput, type CustomQueryCommandInput, type CustomUpdateCommandInput, type DynamoAttrType, type DynamoComparator, type DynamoKeyAttrType, type DynamoQueryRequest, type EventParams, type QueryParamsType, QueryParseError, RESERVED_KEYWORDS_SET, buildGetCommandInput, buildPutCommandInput, buildQueryCommandInput, buildUpdateCommandInput, createKeyConditionExpression, customGetCommandInputSchema, customPutCommandInputSchema, customQueryCommandInputSchema, customUpdateCommandInputSchema, dynamoAttrTypeSch, dynamoComparatorSch, dynamoKeyAttrTypeSch, dynamoQueryRequestSch, extractExpAttributeNamesFromExpression, extractExpAttributeNamesFromUpdateExp, extractQueryReqFromParams, parseDynamoKeyValue, replaceReservedKeywordsFromProjection, replaceReservedKeywordsFromUpdateExp };
+type GeneratedDynamoFilterAttributes = {
+    filterExpression: string;
+    expressionAttributeNames: StringRecord;
+    expressionAttributeValues: GenericRecord;
+};
+declare function generateDynamoFilterAttributes(filters: DynamoFiltersInput): GeneratedDynamoFilterAttributes | null;
+declare function parseValueByType(type: DynamoFilterValueType, raw: string): unknown;
+
+export { type CustomGetCommandInput, type CustomPutCommandInput, type CustomQueryCommandInput, type CustomScanCommandInput, type CustomUpdateCommandInput, type DynamoAttrType, type DynamoComparator, type DynamoFilter, type DynamoFilterCondition, type DynamoFilterValueType, type DynamoFiltersInput, type DynamoKeyAttrType, type DynamoQueryReq, type DynamoQueryRequest, type EventParams, type GeneratedDynamoFilterAttributes, type GenericRecord, type QueryParamsType, QueryParseError, RESERVED_KEYWORDS_SET, type StringRecord, buildGetCommandInput, buildPutCommandInput, buildQueryCommandInput, buildScanCommandInput, buildUpdateCommandInput, createKeyConditionExpression, customGetCommandInputSchema, customPutCommandInputSchema, customQueryCommandInputSchema, customScanCommandInputSch, customUpdateCommandInputSchema, dynamoAttrTypeSch, dynamoComparatorSch, dynamoFilterConditionSch, dynamoFilterSch, dynamoFilterValueTypeSch, dynamoFiltersInputSch, dynamoKeyAttrTypeSch, dynamoQueryRequestSch, extractExpAttributeNamesFromExpression, extractExpAttributeNamesFromUpdateExp, extractQueryReqFromParams, generateDynamoFilterAttributes, omit, parseDynamoKeyValue, parseValueByType, replaceReservedKeywordsFromProjection, replaceReservedKeywordsFromUpdateExp };

package/dist/index.js

@@ -1 +1 @@
-'use strict';var zod=require('zod');function x(e){let{sKey:t,skValue2:s,skComparator:o}=e,n="#pk = :pk";if(!t&&!s)return n;switch(b(o??"=")){case "<":n+=" AND #sk < :sk";break;case ">":n+=" AND #sk > :sk";break;case "<=":n+=" AND #sk <= :sk";break;case ">=":n+=" AND #sk >= :sk";break;case "BEGINS_WITH":if(!s)throw new Error("BEGINS_WITH operation requires skValue2.");n+=" AND begins_with(#sk, :skValue2)";break;case "BETWEEN":if(!t||!s)throw new Error("BETWEEN operation requires both sk and skValue2.");n+=" AND #sk BETWEEN :sk AND :skValue2";break;default:n+=" AND #sk = :sk";break}return n}function b(e){switch(e.toUpperCase()){case "BETWEEN":return "BETWEEN";case "BEGINS_WITH":return "BEGINS_WITH";case "GREATER_THAN":case ">":return ">";case "LESS_THAN":case "<":return "<";case "GREATER_THAN_OR_EQUAL":case ">=":return ">=";case "LESS_THAN_OR_EQUAL":case "<=":return "<=";case "EQUAL":case "=":return "=";default:throw new Error(`Invalid operation key: ${e}`)}}var l=class extends Error{constructor(t,s=400){super(t),this.name="QueryParseError",this.statusCode=s;}},D=l;var W=zod.z.enum(["S","N","B","BOOL","NULL","SS","NS","BS","M","L"]),U=zod.z.enum(["S","N","B"]),k=zod.z.enum(["=","<","<=",">",">=","BETWEEN","BEGINS_WITH"]),P=zod.z.preprocess(e=>typeof e=="string"?e.trim():e,zod.z.string().min(1)),C=zod.z.preprocess(e=>{if(!(e===""||e===null||e===void 0))return typeof e=="string"?e.trim():e},zod.z.string().optional()),V=zod.z.preprocess(e=>{if(!(e===""||e===null||e===void 0)){if(typeof e=="object")return e;if(typeof e=="string"){let t=e.trim();if(!t)return;try{return JSON.parse(t)}catch{return t}}return e}},zod.z.record(zod.z.string(),zod.z.unknown()).optional()),c=zod.z.object({pKey:P,pKeyType:U,pKeyProp:P,sKey:C,sKeyType:U.optional(),sKeyProp:C,skValue2:C,skComparator:k.optional(),indexName:C,limit:zod.z.coerce.number().int().positive().optional(),lastEvaluatedKey:V,sorting:zod.z.enum(["ASC","DESC"]).optional()}).superRefine((e,t)=>{typeof e.lastEvaluatedKey=="string"&&t.addIssue({path:["lastEvaluatedKey"],code:"custom",message:"lastEvaluatedKey must be a JSON object or a stringified JSON object"}),e.skComparator?(e.sKey||t.addIssue({path:["sKey"],code:"custom",message:"sKey is required when skComparator is present"}),e.sKeyProp||t.addIssue({path:["sKeyProp"],code:"custom",message:"sKeyProp is required when skComparator is present"}),e.sKeyType||t.addIssue({path:["sKeyType"],code:"custom",message:"sKeyType is required when skComparator is present"}),e.skComparator==="BETWEEN"?e.skValue2||t.addIssue({path:["skValue2"],code:"custom",message:"skValue2 is required when skComparator is BETWEEN"}):e.skValue2&&t.addIssue({path:["skValue2"],code:"custom",message:"skValue2/skValue2Type are only allowed when skComparator is BETWEEN"})):(e.sKey||e.sKeyProp||e.sKeyType||e.skValue2)&&t.addIssue({path:["skComparator"],code:"custom",message:"skComparator is required when providing sort key conditions"});});var O=zod.z.enum(["INDEXES","TOTAL","NONE"]),f=zod.z.enum(["SIZE","NONE"]),q=zod.z.object({tableName:zod.z.string(),key:zod.z.record(zod.z.string(),zod.z.unknown()),projectionExpression:zod.z.string().optional(),expressionAttributeNames:zod.z.record(zod.z.string(),zod.z.string()).optional(),consistentRead:zod.z.boolean().optional(),returnConsumedCapacity:O.optional()}),X=zod.z.object({tableName:zod.z.string(),queryRequest:c,keyConditionExpression:zod.z.string().optional(),filterExpression:zod.z.string().optional(),expressionAttributeNames:zod.z.record(zod.z.string(),zod.z.string()).optional(),expressionAttributeValues:zod.z.record(zod.z.string(),zod.z.unknown()).optional(),extraExpAttributeNames:zod.z.record(zod.z.string(),zod.z.string()).optional(),extraExpAttributeValues:zod.z.record(zod.z.string(),zod.z.unknown()).optional(),projectionExpression:zod.z.string().optional(),scanIndexForward:zod.z.boolean().optional(),returnConsumedCapacity:O.optional()}),_=zod.z.object({tableName:zod.z.string(),item:zod.z.record(zod.z.string(),zod.z.unknown()),conditionExpression:zod.z.string().optional(),expressionAttributeNames:zod.z.record(zod.z.string(),zod.z.string()).optional(),expressionAttributeValues:zod.z.record(zod.z.string(),zod.z.unknown()).optional(),returnValues:zod.z.enum(["NONE","ALL_OLD","UPDATED_OLD","ALL_NEW","UPDATED_NEW"]).optional(),returnConsumedCapacity:O.optional(),returnItemCollectionMetrics:f.optional()}),v=zod.z.object({tableName:zod.z.string(),key:zod.z.record(zod.z.string(),zod.z.unknown()),item:zod.z.record(zod.z.string(),zod.z.unknown()).optional(),updateExpression:zod.z.string().optional(),conditionExpression:zod.z.string().optional(),expressionAttributeNames:zod.z.record(zod.z.string(),zod.z.string()).optional(),expressionAttributeValues:zod.z.record(zod.z.string(),zod.z.unknown()).optional(),extraExpAttributeNames:zod.z.record(zod.z.string(),zod.z.string()).optional(),extraExpAttributeValues:zod.z.record(zod.z.string(),zod.z.unknown()).optional(),returnValues:zod.z.enum(["NONE","ALL_OLD","UPDATED_OLD","ALL_NEW","UPDATED_NEW"]).optional(),returnConsumedCapacity:O.optional(),returnItemCollectionMetrics:f.optional()});function oe(e,t){let s=e||{},o={...s,indexName:s.indexName??s.index},n=o.indexName,i=typeof o.pKey=="string"&&o.pKey.trim().length>0;return n?n===t.indexName?A(i?{...o,indexName:t.indexName}:{indexName:t.indexName,pKey:o.pKey||t.pKey,pKeyType:o.pKeyType||t.pKeyType,pKeyProp:o.pKeyProp||t.pKeyProp,limit:Number(o.limit||t.limit||"10"),sKey:o.sKey||t.sKey,sKeyType:o.sKeyType||t.sKeyType,sKeyProp:o.sKeyProp||t.sKeyProp,skValue2:o.skValue2||t.skValue2,skComparator:o.skComparator||t.skComparator,lastEvaluatedKey:o.lastEvaluatedKey||t.lastEvaluatedKey,sorting:o.sorting||t.sorting}):A(o):A(i?o:{...t,...o,indexName:t.indexName})}function A(e){let t=c.safeParse(e);if(!t.success){let s=t.error.issues.map(o=>`${o.path}: ${o.message}`).join(", ");throw new D(`Bad request! ${s}`,400)}return t.data}function d(e,t){switch(t){case "S":return e;case "N":return Number(e);case "BOOL":return e.toLowerCase()==="true";case "NULL":return null;case "M":try{return JSON.parse(e)}catch{throw new Error("Invalid JSON format for partitionKeyType M (Map)")}case "L":try{return JSON.parse(e)}catch{throw new Error("Invalid JSON format for partitionKeyType L (List)")}case "SS":return e.split(",").map(s=>s.trim());case "NS":return e.split(",").map(s=>Number(s.trim())).filter(s=>!isNaN(s));case "BS":return e.split(",").map(s=>Buffer.from(s.trim(),"base64"));default:throw new Error(`Unsupported partitionKeyType: ${t}`)}}function I(e){let t={};for(let s of e.split(",")){let o=s.trim();o.startsWith("#")&&(t[o]=o.slice(1));}return t}function g(e){let t={},s=e.replace(/^\s*SET\s+/i,"").trim();if(!s)return t;let o=s.split(",");for(let n of o){let i=n.split("=")[0]?.trim();!i||!i.startsWith("#")||(t[i]=i.slice(1));}return t}var K=new Set(["ABORT","ABSOLUTE","ACTION","ADD","AFTER","AGENT","AGGREGATE","ALL","ALLOCATE","ALTER","ANALYZE","AND","ANY","ARCHIVE","ARE","ARRAY","AS","ASC","ASCII","ASENSITIVE","ASSERTION","ASYMMETRIC","AT","ATOMIC","ATTACH","ATTRIBUTE","AUTH","AUTHORIZATION","AUTHORIZE","AUTO","AVG","BACK","BACKUP","BASE","BATCH","BEFORE","BEGIN","BETWEEN","BIGINT","BINARY","BIT","BLOB","BLOCK","BOOLEAN","BOTH","BREADTH","BUCKET","BULK","BY","BYTE","CALL","CALLED","CALLING","CAPACITY","CASCADE","CASCADED","CASE","CAST","CATALOG","CHAR","CHARACTER","CHECK","CLASS","CLOB","CLOSE","CLUSTER","CLUSTERED","CLUSTERING","CLUSTERS","COALESCE","COLLATE","COLLATION","COLLECTION","COLUMN","COLUMNS","COMBINE","COMMENT","COMMIT","COMPACT","COMPILE","COMPRESS","CONDITION","CONFLICT","CONNECT","CONNECTION","CONSISTENCY","CONSISTENT","CONSTRAINT","CONSTRUCTOR","CONSUMED","CONTINUE","CONVERT","COPY","CORRESPONDING","COUNT","COUNTER","CREATE","CROSS","CSV","CUBE","CURRENT","CURSOR","CYCLE","DATA","DATABASE","DATE","DATETIME","DAY","DEALLOCATE","DEC","DECIMAL","DECLARE","DEFAULT","DEFERRABLE","DEFERRED","DEFINE","DEFINED","DEFINITION","DELETE","DELIMITED","DEPTH","DEREF","DESC","DESCRIBE","DESCRIPTOR","DETACH","DETERMINISTIC","DIAGNOSTICS","DIRECTORIES","DISABLE","DISCONNECT","DISTINCT","DISTRIBUTE","DO","DOMAIN","DOUBLE","DROP","DUMP","DURATION","DYNAMIC","EACH","ELEMENT","ELSE","ELSEIF","EMPTY","ENABLE","END","EQUAL","EQUALS","ERROR","ESCAPE","ESCAPED","EVAL","EVALUATE","EXCEEDED","EXCEPT","EXCEPTIONS","EXCLUSIVE","EXEC","EXECUTE","EXISTS","EXIT","EXPLAIN","EXPLODE","EXPORT","EXPRESSION","EXTENDED","EXTERNAL","EXTRACT","FAIL","FALSE","FAMILY","FETCH","FIELDS","FILE","FILTER","FILTERING","FINAL","FINISH","FIRST","FIXED","FLATTERN","FLOAT","FOR","FORCE","FOREIGN","FORMAT","FORWARD","FOUND","FREE","FROM","FULL","FUNCTION","FUNCTIONS","GENERAL","GENERATE","GET","GLOB","GLOBAL","GO","GOTO","GRANT","GROUP","GROUPING","HANDLER","HASH","HAVE","HAVING","HEAP","HIDDEN","HOLD","HOUR","IDENTIFIED","IDENTITY","IF","IGNORE","IMMEDIATE","IMPORT","IN","INCLUDING","INCLUSIVE","INCREMENT","INDEX","INDEXED","INDEXES","INET","INF","INFINITE","INITIALLY","INLINE","INNER","INNTER","INPUT","INSENSITIVE","INSERT","INSTEAD","INT","INTEGER","INTERSECT","INTERVAL","INTO","INVALIDATE","IS","ISOLATION","ITEM","ITEMS","ITERATE","JOIN","KEY","KEYS","LAG","LANGUAGE","LARGE","LAST","LATERAL","LEAD","LEADING","LEAVE","LEFT","LEVEL","LIKE","LIMIT","LIMITED","LINES","LIST","LOAD","LOCAL","LOCALTIME","LOCALTIMESTAMP","LOCATION","LOCATOR","LOCK","LOCKS","LOG","LOGED","LONG","LOOP","LOW","MAP","MATCH","MATERIALIZED","MAX","MAXLEN","MEMBER","MERGE","METHOD","MIN","MINUS","MINUTE","MISSING","MOD","MODE","MODIFIES","MODIFY","MODULE","MONTH","MULTI","MULTISET","NAME","NAMES","NATIONAL","NATURAL","NCHAR","NCLOB","NEW","NEXT","NO","NONE","NOT","NULL","NULLIF","NUMBER","NUMERIC","OBJECT","OF","OFFLINE","OFFSET","OLD","ON","ONLINE","ONLY","OPAQUE","OPEN","OPERATOR","OPTION","OR","ORDER","ORDINALITY","OUT","OUTER","OUTPUT","OVER","OVERLAPS","OVERRIDE","PARTITION","PARTITIONED","PARTITIONS","PATH","PERCENT","PERCENTILE","PERMISSION","PERMISSIONS","PIPE","PIPELINED","PLAN","POOL","POSITION","PRECISION","PREPARE","PRESERVE","PRIMARY","PRIOR","PRIVATE","PRIVILEGES","PROCEDURE","PROCESSED","PROJECT","PROJECTION","PROPERTY","PROVISIONING","PUBLIC","PUT","QUERY","QUIT","QUORUM","RAISE","RANGE","RANK","RAW","READ","READS","REAL","REBUILD","RECORD","RECURSIVE","REDUCE","REF","REFERENCE","REFERENCES","REFERENCING","REGEXP","REGION","REINDEX","RELATIVE","RELEASE","REMA","REMAINDER","RENAME","REPEAT","REPLACE","REQUEST","RESET","RESIGNAL","RESOURCE","RESPONSE","RESTORE","RESTRICT","RESULT","RETURN","RETURNING","REVEAL","REVERSE","REVOKE","RIGHT","ROLE","ROLES","ROLLBACK","ROLLUP","ROUTINE","ROW","ROWS","RULE","RULES","SAMPLE","SATISFIES","SAVE","SAVEPOINT","SCAN","SCHEMA","SCOPE","SCROLL","SEARCH","SECOND","SECTION","SEGMENT","SEGMENTS","SELECT","SELF","SEMI","SENSITIVE","SEPARATE","SEQUENCE","SERIALIZABLE","SESSION","SET","SETS","SHARD","SHARE","SHARED","SHORT","SHOW","SIGNAL","SIMILAR","SIZE","SKEWED","SMALLINT","SNAPSHOT","SOME","SOURCE","SPACE","SPLIT","SQL","SQLCODE","SQLERROR","SQLEXCEPTION","SQLSTATE","SQLWARNING","START","STATE","STATIC","STATUS","STORAGE","STORE","STORED","STREAM","STRING","STRUCT","STYLE","SUB","SUBMULTISET","SUBPARTITION","SUBSTRING","SUBTYPE","SUM","SUPER","SYMMETRIC","SYNONYM","SYSTEM","TABLE","TABLESAMPLE","TEMP","TEMPORARY","TERMINATED","TEXT","THAN","THEN","THROUGHPUT","TIME","TIMESTAMP","TIMEZONE","TINYINT","TO","TOKEN","TOTAL","TOUCH","TRAILING","TRAN","TRANSACTION","TRANSFORM","TRANSLATE","TRANSLATION","TREAT","TRIGGER","TRIM","TRUE","TRUNCATE","TTL","TUPLE","TYPE","UNDER","UNDO","UNION","UNIQUE","UNIT","UNKNOWN","UNLOGGED","UNNEST","UNPROCESSED","UNSIGNED","UNTIL","UPDATE","UPPER","URL","USAGE","USE","USING","UUID","VACUUM","VALUE","VALUED","VALUES","VARCHAR","VARIABLE","VARIANCE","VARINT","VARYING","VIEW","VIEWS","VIRTUAL","VOID","WAIT","WHEN","WHENEVER","WHERE","WHILE","WINDOW","WITH","WITHIN","WITHOUT","WORK","WRAPPED","WRITE","YEAR","ZONE"]),G=new RegExp(`\\b(?:${[...K].join("|")})\\b(?=\\s*=)`,"gi");function M(e){return e.replace(G,t=>`#${t}`)}function L(e){return e.split(",").map(t=>{let s=t.trim();return s&&(K.has(s.toUpperCase())?`#${s}`:s)}).join(", ")}function Se(e){let{tableName:t,key:s,projectionExpression:o,expressionAttributeNames:n,consistentRead:i,returnConsumedCapacity:u}=e,m=o?L(o):void 0,T={TableName:t,Key:s,ProjectionExpression:m,ConsistentRead:i,ReturnConsumedCapacity:u},p={...m?I(m):{},...n??{}};return Object.keys(p).length>0&&(T.ExpressionAttributeNames=p),T}function Oe(e){let{tableName:t,item:s,conditionExpression:o,expressionAttributeNames:n,expressionAttributeValues:i,returnValues:u="NONE",returnConsumedCapacity:m,returnItemCollectionMetrics:T}=e,p={TableName:t,Item:s,ConditionExpression:o,ReturnValues:u,ReturnConsumedCapacity:m,ReturnItemCollectionMetrics:T},E=!!o,R=!!n&&Object.keys(n).length>0;if(E||R){let N=E?I(o):{},S=R?{...N,...n}:N;Object.keys(S).length>0&&(p.ExpressionAttributeNames=S);}return i&&Object.keys(i).length>0&&(p.ExpressionAttributeValues=i),p}function ye(e){let{queryRequest:t}=e,s=x(t),o=e.projectionExpression?L(e.projectionExpression):void 0,n={"#pk":t.pKeyProp,...t.sKeyProp&&{"#sk":t.sKeyProp},...o&&I(o),...e.extraExpAttributeNames||{}},i={":pk":d(t.pKey,t.pKeyType),...t.sKey&&{":sk":d(t.sKey,t.sKeyType??"S")},...t.skValue2&&{":skValue2":d(t.skValue2,t.sKeyType??"S")},...e.extraExpAttributeValues||{}};return {TableName:e.tableName,IndexName:t.indexName,KeyConditionExpression:s,FilterExpression:e.filterExpression,ExpressionAttributeNames:n,ExpressionAttributeValues:i,ProjectionExpression:o,ScanIndexForward:t.sorting!==void 0?t.sorting.toUpperCase()==="ASC":e.scanIndexForward,ReturnConsumedCapacity:e.returnConsumedCapacity,ExclusiveStartKey:t.lastEvaluatedKey,Limit:t.limit}}function xe(e){let t={TableName:e.tableName,Key:e.key,ConditionExpression:e.conditionExpression,ReturnValues:e.returnValues??"NONE",ReturnConsumedCapacity:e.returnConsumedCapacity,ReturnItemCollectionMetrics:e.returnItemCollectionMetrics},s={},o={};if(e.expressionAttributeNames)for(let E in e.expressionAttributeNames)s[E]=e.expressionAttributeNames[E];if(e.extraExpAttributeNames)for(let E in e.extraExpAttributeNames)s[E]=e.extraExpAttributeNames[E];if(e.expressionAttributeValues)for(let E in e.expressionAttributeValues)o[E]=e.expressionAttributeValues[E];if(e.extraExpAttributeValues)for(let E in e.extraExpAttributeValues)o[E]=e.extraExpAttributeValues[E];let n=e.updateExpression;if(n)return Object.keys(s).length>0&&(t.ExpressionAttributeNames=s),Object.keys(o).length>0&&(t.ExpressionAttributeValues=o),t.UpdateExpression=n,t;let i=e.item;if(!i||Object.keys(i).length===0)throw new Error("Either updateExpression or item with at least one field must be provided.");let u=[],m=i;for(let E in m){let R=m[E],N=`:${E}`;if(o[N]!==void 0){let S=1,y;do y=`:${E}_update_${S++}`;while(o[y]!==void 0);N=y;}u.push(`${E} = ${N}`),o[N]=R;}let T=`SET ${u.join(", ")}`;n=M(T);let p=g(n);for(let E in p)E in s||(s[E]=p[E]);return Object.keys(s).length>0&&(t.ExpressionAttributeNames=s),Object.keys(o).length>0&&(t.ExpressionAttributeValues=o),t.UpdateExpression=n,t}exports.QueryParseError=D;exports.RESERVED_KEYWORDS_SET=K;exports.buildGetCommandInput=Se;exports.buildPutCommandInput=Oe;exports.buildQueryCommandInput=ye;exports.buildUpdateCommandInput=xe;exports.createKeyConditionExpression=x;exports.customGetCommandInputSchema=q;exports.customPutCommandInputSchema=_;exports.customQueryCommandInputSchema=X;exports.customUpdateCommandInputSchema=v;exports.dynamoAttrTypeSch=W;exports.dynamoComparatorSch=k;exports.dynamoKeyAttrTypeSch=U;exports.dynamoQueryRequestSch=c;exports.extractExpAttributeNamesFromExpression=I;exports.extractExpAttributeNamesFromUpdateExp=g;exports.extractQueryReqFromParams=oe;exports.parseDynamoKeyValue=d;exports.replaceReservedKeywordsFromProjection=L;exports.replaceReservedKeywordsFromUpdateExp=M;
+'use strict';var zod=require('zod');function B(e){let{sKey:t,skValue2:r,skComparator:n}=e,s="#pk = :pk";if(!t&&!r)return s;switch(J(n??"=")){case "<":s+=" AND #sk < :sk";break;case ">":s+=" AND #sk > :sk";break;case "<=":s+=" AND #sk <= :sk";break;case ">=":s+=" AND #sk >= :sk";break;case "BEGINS_WITH":if(!r)throw new Error("BEGINS_WITH operation requires skValue2.");s+=" AND begins_with(#sk, :skValue2)";break;case "BETWEEN":if(!t||!r)throw new Error("BETWEEN operation requires both sk and skValue2.");s+=" AND #sk BETWEEN :sk AND :skValue2";break;default:s+=" AND #sk = :sk";break}return s}function J(e){switch(e.toUpperCase()){case "BETWEEN":return "BETWEEN";case "BEGINS_WITH":return "BEGINS_WITH";case "GREATER_THAN":case ">":return ">";case "LESS_THAN":case "<":return "<";case "GREATER_THAN_OR_EQUAL":case ">=":return ">=";case "LESS_THAN_OR_EQUAL":case "<=":return "<=";case "EQUAL":case "=":return "=";default:throw new Error(`Invalid operation key: ${e}`)}}var k=class extends Error{constructor(t,r=400){super(t),this.name="QueryParseError",this.statusCode=r;}},d=k;var pe=zod.z.enum(["S","N","B","BOOL","NULL","SS","NS","BS","M","L"]),w=zod.z.enum(["S","N","B"]),Z=zod.z.enum(["=","<","<=",">",">=","BETWEEN","BEGINS_WITH"]),_=zod.z.preprocess(e=>typeof e=="string"?e.trim():e,zod.z.string().min(1)),U=zod.z.preprocess(e=>{if(!(e===""||e===null||e===void 0))return typeof e=="string"?e.trim():e},zod.z.string().optional()),ee=zod.z.preprocess(e=>{if(!(e===""||e===null||e===void 0)){if(typeof e=="object")return e;if(typeof e=="string"){let t=e.trim();if(!t)return;try{return JSON.parse(t)}catch{return t}}return e}},zod.z.record(zod.z.string(),zod.z.unknown()).optional()),h=zod.z.object({pKey:_,pKeyType:w,pKeyProp:_,sKey:U,sKeyType:w.optional(),sKeyProp:U,skValue2:U,skComparator:Z.optional(),indexName:U,limit:zod.z.coerce.number().int().positive().optional(),lastEvaluatedKey:ee,sorting:zod.z.enum(["ASC","DESC"]).optional()}).superRefine((e,t)=>{typeof e.lastEvaluatedKey=="string"&&t.addIssue({path:["lastEvaluatedKey"],code:"custom",message:"lastEvaluatedKey must be a JSON object or a stringified JSON object"}),e.skComparator?(e.sKey||t.addIssue({path:["sKey"],code:"custom",message:"sKey is required when skComparator is present"}),e.sKeyProp||t.addIssue({path:["sKeyProp"],code:"custom",message:"sKeyProp is required when skComparator is present"}),e.sKeyType||t.addIssue({path:["sKeyType"],code:"custom",message:"sKeyType is required when skComparator is present"}),e.skComparator==="BETWEEN"?e.skValue2||t.addIssue({path:["skValue2"],code:"custom",message:"skValue2 is required when skComparator is BETWEEN"}):e.skValue2&&t.addIssue({path:["skValue2"],code:"custom",message:"skValue2/skValue2Type are only allowed when skComparator is BETWEEN"})):(e.sKey||e.sKeyProp||e.sKeyType||e.skValue2)&&t.addIssue({path:["skComparator"],code:"custom",message:"skComparator is required when providing sort key conditions"});});var te=zod.z.enum(["S","N","BOOL","NULL","SS","NS"]),re=zod.z.enum(["EQUAL_TO","NOT_EQUAL_TO","LESS_THAN","LESS_THAN_OR_EQUAL_TO","GREATER_THAN","GREATER_THAN_OR_EQUAL_TO","EXISTS","NOT_EXISTS","BEGINS_WITH","CONTAINS","NOT_CONTAINS","BETWEEN"]),ne=zod.z.object({name:zod.z.string().min(1),type:te,condition:re,value:zod.z.string().optional(),value2:zod.z.string().optional(),values:zod.z.array(zod.z.string().min(1)).min(1).optional()}).superRefine((e,t)=>{let r=typeof e.value=="string",n=typeof e.value2=="string",s=Array.isArray(e.values)&&e.values.length>0;if(e.condition==="EXISTS"||e.condition==="NOT_EXISTS"){(r||n||s)&&t.addIssue({code:"custom",path:["condition"],message:`${e.condition} must not include value/value2/values`});return}if(e.condition==="BETWEEN"){r||t.addIssue({code:"custom",path:["value"],message:"BETWEEN requires value"}),n||t.addIssue({code:"custom",path:["value2"],message:"BETWEEN requires value2"}),s&&t.addIssue({code:"custom",path:["values"],message:"BETWEEN must not include values"});return}if(e.type==="SS"||e.type==="NS"){s||t.addIssue({code:"custom",path:["values"],message:`${e.type} filter requires values (non-empty)`}),(r||n)&&t.addIssue({code:"custom",path:["type"],message:`${e.type} filter must not include value/value2; use values`});return}r||t.addIssue({code:"custom",path:["value"],message:`${e.condition} requires value`}),n&&t.addIssue({code:"custom",path:["value2"],message:`${e.condition} must not include value2`}),s&&t.addIssue({code:"custom",path:["values"],message:`${e.condition} must not include values`});}),H=zod.z.array(ne).max(50);var f=zod.z.enum(["INDEXES","TOTAL","NONE"]),$=zod.z.enum(["SIZE","NONE"]),A=zod.z.record(zod.z.string(),zod.z.unknown()),S=zod.z.record(zod.z.string(),zod.z.string()),de=zod.z.object({tableName:zod.z.string(),key:A,projectionExpression:zod.z.string().optional(),expressionAttributeNames:S.optional(),consistentRead:zod.z.boolean().optional(),returnConsumedCapacity:f.optional()}),Ie=zod.z.object({tableName:zod.z.string(),queryRequest:h,keyConditionExpression:zod.z.string().optional(),filterExpression:zod.z.string().optional(),expressionAttributeNames:S.optional(),expressionAttributeValues:A.optional(),extraExpAttributeNames:S.optional(),extraExpAttributeValues:A.optional(),projectionExpression:zod.z.string().optional(),scanIndexForward:zod.z.boolean().optional(),returnConsumedCapacity:f.optional()}),Se=zod.z.object({tableName:zod.z.string(),item:A,conditionExpression:zod.z.string().optional(),expressionAttributeNames:S.optional(),expressionAttributeValues:A.optional(),returnValues:zod.z.enum(["NONE","ALL_OLD","UPDATED_OLD","ALL_NEW","UPDATED_NEW"]).optional(),returnConsumedCapacity:f.optional(),returnItemCollectionMetrics:$.optional()}),Re=zod.z.object({tableName:zod.z.string(),key:A,item:A.optional(),updateExpression:zod.z.string().optional(),conditionExpression:zod.z.string().optional(),expressionAttributeNames:S.optional(),expressionAttributeValues:A.optional(),extraExpAttributeNames:S.optional(),extraExpAttributeValues:A.optional(),returnValues:zod.z.enum(["NONE","ALL_OLD","UPDATED_OLD","ALL_NEW","UPDATED_NEW"]).optional(),returnConsumedCapacity:f.optional(),returnItemCollectionMetrics:$.optional()}),W=zod.z.object({tableName:zod.z.string(),indexName:zod.z.string().optional(),filtersAttributes:H.optional(),filterExpression:zod.z.string().optional(),projectionExpression:zod.z.string().optional(),expressionAttributeNames:S.optional(),expressionAttributeValues:A.optional(),extraExpAttributeNames:S.optional(),extraExpAttributeValues:A.optional(),limit:zod.z.number().int().positive().optional(),exclusiveStartKey:A.optional(),consistentRead:zod.z.boolean().optional(),segment:zod.z.number().int().nonnegative().optional(),totalSegments:zod.z.number().int().positive().optional(),returnConsumedCapacity:f.optional(),returnItemCollectionMetrics:zod.z.enum(["SIZE","NONE"]).optional()}).superRefine((e,t)=>{let r=e.segment!==void 0,n=e.totalSegments!==void 0;r!==n&&t.addIssue({code:"custom",message:"segment and totalSegments must be provided together for parallel scan.",path:r?["totalSegments"]:["segment"]}),r&&n&&(e.totalSegments<=0&&t.addIssue({code:"custom",message:"totalSegments must be > 0.",path:["totalSegments"]}),(e.segment<0||e.segment>=e.totalSegments)&&t.addIssue({code:"custom",message:"segment must be in range [0, totalSegments-1].",path:["segment"]})),e.indexName&&e.consistentRead===true&&t.addIssue({code:"custom",message:"consistentRead cannot be true when scanning a GSI (indexName provided).",path:["consistentRead"]});});function be(e,t){let r=e||{},n={...r,indexName:r.indexName??r.index},s=n.indexName,p=typeof n.pKey=="string"&&n.pKey.trim().length>0;return s?s===t.indexName?L(p?{...n,indexName:t.indexName}:{indexName:t.indexName,pKey:n.pKey||t.pKey,pKeyType:n.pKeyType||t.pKeyType,pKeyProp:n.pKeyProp||t.pKeyProp,limit:Number(n.limit||t.limit||"10"),sKey:n.sKey||t.sKey,sKeyType:n.sKeyType||t.sKeyType,sKeyProp:n.sKeyProp||t.sKeyProp,skValue2:n.skValue2||t.skValue2,skComparator:n.skComparator||t.skComparator,lastEvaluatedKey:n.lastEvaluatedKey||t.lastEvaluatedKey,sorting:n.sorting||t.sorting}):L(n):L(p?n:{...t,...n,indexName:t.indexName})}function L(e){let t=h.safeParse(e);if(!t.success){let r=t.error.issues.map(n=>`${n.path}: ${n.message}`).join(", ");throw new d(`Bad request! ${r}`,400)}return t.data}function P(e,t){switch(t){case "S":return e;case "N":return Number(e);case "BOOL":return e.toLowerCase()==="true";case "NULL":return null;case "M":try{return JSON.parse(e)}catch{throw new Error("Invalid JSON format for partitionKeyType M (Map)")}case "L":try{return JSON.parse(e)}catch{throw new Error("Invalid JSON format for partitionKeyType L (List)")}case "SS":return e.split(",").map(r=>r.trim());case "NS":return e.split(",").map(r=>Number(r.trim())).filter(r=>!isNaN(r));case "BS":return e.split(",").map(r=>Buffer.from(r.trim(),"base64"));default:throw new Error(`Unsupported partitionKeyType: ${t}`)}}function O(e){let t={};for(let r of e.split(",")){let n=r.trim();n.startsWith("#")&&(t[n]=n.slice(1));}return t}function j(e){let t={},r=e.replace(/^\s*SET\s+/i,"").trim();if(!r)return t;let n=r.split(",");for(let s of n){let p=s.split("=")[0]?.trim();!p||!p.startsWith("#")||(t[p]=p.slice(1));}return t}var q=new Set(["ABORT","ABSOLUTE","ACTION","ADD","AFTER","AGENT","AGGREGATE","ALL","ALLOCATE","ALTER","ANALYZE","AND","ANY","ARCHIVE","ARE","ARRAY","AS","ASC","ASCII","ASENSITIVE","ASSERTION","ASYMMETRIC","AT","ATOMIC","ATTACH","ATTRIBUTE","AUTH","AUTHORIZATION","AUTHORIZE","AUTO","AVG","BACK","BACKUP","BASE","BATCH","BEFORE","BEGIN","BETWEEN","BIGINT","BINARY","BIT","BLOB","BLOCK","BOOLEAN","BOTH","BREADTH","BUCKET","BULK","BY","BYTE","CALL","CALLED","CALLING","CAPACITY","CASCADE","CASCADED","CASE","CAST","CATALOG","CHAR","CHARACTER","CHECK","CLASS","CLOB","CLOSE","CLUSTER","CLUSTERED","CLUSTERING","CLUSTERS","COALESCE","COLLATE","COLLATION","COLLECTION","COLUMN","COLUMNS","COMBINE","COMMENT","COMMIT","COMPACT","COMPILE","COMPRESS","CONDITION","CONFLICT","CONNECT","CONNECTION","CONSISTENCY","CONSISTENT","CONSTRAINT","CONSTRUCTOR","CONSUMED","CONTINUE","CONVERT","COPY","CORRESPONDING","COUNT","COUNTER","CREATE","CROSS","CSV","CUBE","CURRENT","CURSOR","CYCLE","DATA","DATABASE","DATE","DATETIME","DAY","DEALLOCATE","DEC","DECIMAL","DECLARE","DEFAULT","DEFERRABLE","DEFERRED","DEFINE","DEFINED","DEFINITION","DELETE","DELIMITED","DEPTH","DEREF","DESC","DESCRIBE","DESCRIPTOR","DETACH","DETERMINISTIC","DIAGNOSTICS","DIRECTORIES","DISABLE","DISCONNECT","DISTINCT","DISTRIBUTE","DO","DOMAIN","DOUBLE","DROP","DUMP","DURATION","DYNAMIC","EACH","ELEMENT","ELSE","ELSEIF","EMPTY","ENABLE","END","EQUAL","EQUALS","ERROR","ESCAPE","ESCAPED","EVAL","EVALUATE","EXCEEDED","EXCEPT","EXCEPTIONS","EXCLUSIVE","EXEC","EXECUTE","EXISTS","EXIT","EXPLAIN","EXPLODE","EXPORT","EXPRESSION","EXTENDED","EXTERNAL","EXTRACT","FAIL","FALSE","FAMILY","FETCH","FIELDS","FILE","FILTER","FILTERING","FINAL","FINISH","FIRST","FIXED","FLATTERN","FLOAT","FOR","FORCE","FOREIGN","FORMAT","FORWARD","FOUND","FREE","FROM","FULL","FUNCTION","FUNCTIONS","GENERAL","GENERATE","GET","GLOB","GLOBAL","GO","GOTO","GRANT","GROUP","GROUPING","HANDLER","HASH","HAVE","HAVING","HEAP","HIDDEN","HOLD","HOUR","IDENTIFIED","IDENTITY","IF","IGNORE","IMMEDIATE","IMPORT","IN","INCLUDING","INCLUSIVE","INCREMENT","INDEX","INDEXED","INDEXES","INET","INF","INFINITE","INITIALLY","INLINE","INNER","INNTER","INPUT","INSENSITIVE","INSERT","INSTEAD","INT","INTEGER","INTERSECT","INTERVAL","INTO","INVALIDATE","IS","ISOLATION","ITEM","ITEMS","ITERATE","JOIN","KEY","KEYS","LAG","LANGUAGE","LARGE","LAST","LATERAL","LEAD","LEADING","LEAVE","LEFT","LEVEL","LIKE","LIMIT","LIMITED","LINES","LIST","LOAD","LOCAL","LOCALTIME","LOCALTIMESTAMP","LOCATION","LOCATOR","LOCK","LOCKS","LOG","LOGED","LONG","LOOP","LOW","MAP","MATCH","MATERIALIZED","MAX","MAXLEN","MEMBER","MERGE","METHOD","MIN","MINUS","MINUTE","MISSING","MOD","MODE","MODIFIES","MODIFY","MODULE","MONTH","MULTI","MULTISET","NAME","NAMES","NATIONAL","NATURAL","NCHAR","NCLOB","NEW","NEXT","NO","NONE","NOT","NULL","NULLIF","NUMBER","NUMERIC","OBJECT","OF","OFFLINE","OFFSET","OLD","ON","ONLINE","ONLY","OPAQUE","OPEN","OPERATOR","OPTION","OR","ORDER","ORDINALITY","OUT","OUTER","OUTPUT","OVER","OVERLAPS","OVERRIDE","PARTITION","PARTITIONED","PARTITIONS","PATH","PERCENT","PERCENTILE","PERMISSION","PERMISSIONS","PIPE","PIPELINED","PLAN","POOL","POSITION","PRECISION","PREPARE","PRESERVE","PRIMARY","PRIOR","PRIVATE","PRIVILEGES","PROCEDURE","PROCESSED","PROJECT","PROJECTION","PROPERTY","PROVISIONING","PUBLIC","PUT","QUERY","QUIT","QUORUM","RAISE","RANGE","RANK","RAW","READ","READS","REAL","REBUILD","RECORD","RECURSIVE","REDUCE","REF","REFERENCE","REFERENCES","REFERENCING","REGEXP","REGION","REINDEX","RELATIVE","RELEASE","REMA","REMAINDER","RENAME","REPEAT","REPLACE","REQUEST","RESET","RESIGNAL","RESOURCE","RESPONSE","RESTORE","RESTRICT","RESULT","RETURN","RETURNING","REVEAL","REVERSE","REVOKE","RIGHT","ROLE","ROLES","ROLLBACK","ROLLUP","ROUTINE","ROW","ROWS","RULE","RULES","SAMPLE","SATISFIES","SAVE","SAVEPOINT","SCAN","SCHEMA","SCOPE","SCROLL","SEARCH","SECOND","SECTION","SEGMENT","SEGMENTS","SELECT","SELF","SEMI","SENSITIVE","SEPARATE","SEQUENCE","SERIALIZABLE","SESSION","SET","SETS","SHARD","SHARE","SHARED","SHORT","SHOW","SIGNAL","SIMILAR","SIZE","SKEWED","SMALLINT","SNAPSHOT","SOME","SOURCE","SPACE","SPLIT","SQL","SQLCODE","SQLERROR","SQLEXCEPTION","SQLSTATE","SQLWARNING","START","STATE","STATIC","STATUS","STORAGE","STORE","STORED","STREAM","STRING","STRUCT","STYLE","SUB","SUBMULTISET","SUBPARTITION","SUBSTRING","SUBTYPE","SUM","SUPER","SYMMETRIC","SYNONYM","SYSTEM","TABLE","TABLESAMPLE","TEMP","TEMPORARY","TERMINATED","TEXT","THAN","THEN","THROUGHPUT","TIME","TIMESTAMP","TIMEZONE","TINYINT","TO","TOKEN","TOTAL","TOUCH","TRAILING","TRAN","TRANSACTION","TRANSFORM","TRANSLATE","TRANSLATION","TREAT","TRIGGER","TRIM","TRUE","TRUNCATE","TTL","TUPLE","TYPE","UNDER","UNDO","UNION","UNIQUE","UNIT","UNKNOWN","UNLOGGED","UNNEST","UNPROCESSED","UNSIGNED","UNTIL","UPDATE","UPPER","URL","USAGE","USE","USING","UUID","VACUUM","VALUE","VALUED","VALUES","VARCHAR","VARIABLE","VARIANCE","VARINT","VARYING","VIEW","VIEWS","VIRTUAL","VOID","WAIT","WHEN","WHENEVER","WHERE","WHILE","WINDOW","WITH","WITHIN","WITHOUT","WORK","WRAPPED","WRITE","YEAR","ZONE"]),oe=new RegExp(`\\b(?:${[...q].join("|")})\\b(?=\\s*=)`,"gi");function Q(e){return e.replace(oe,t=>`#${t}`)}function V(e){return e.split(",").map(t=>{let r=t.trim();return r&&(q.has(r.toUpperCase())?`#${r}`:r)}).join(", ")}function Fe(e,t){let r={};for(let n in e)Object.prototype.hasOwnProperty.call(e,n)&&!t.includes(n)&&(r[n]=e[n]);return r}function je(e){let{tableName:t,key:r,projectionExpression:n,expressionAttributeNames:s,consistentRead:p,returnConsumedCapacity:u}=e,o=n?V(n):void 0,m={TableName:t,Key:r,ProjectionExpression:o,ConsistentRead:p,ReturnConsumedCapacity:u},i={...o?O(o):{},...s??{}};return Object.keys(i).length>0&&(m.ExpressionAttributeNames=i),m}function Ye(e){let{tableName:t,item:r,conditionExpression:n,expressionAttributeNames:s,expressionAttributeValues:p,returnValues:u="NONE",returnConsumedCapacity:o,returnItemCollectionMetrics:m}=e,i={TableName:t,Item:r,ConditionExpression:n,ReturnValues:u,ReturnConsumedCapacity:o,ReturnItemCollectionMetrics:m},a=!!n,c=!!s&&Object.keys(s).length>0;if(a||c){let T=a?O(n):{},R=c?{...T,...s}:T;Object.keys(R).length>0&&(i.ExpressionAttributeNames=R);}return p&&Object.keys(p).length>0&&(i.ExpressionAttributeValues=p),i}function Je(e){let{queryRequest:t}=e,r=B(t),n=e.projectionExpression?V(e.projectionExpression):void 0,s={"#pk":t.pKeyProp,...t.sKeyProp&&{"#sk":t.sKeyProp},...n&&O(n),...e.extraExpAttributeNames||{}},p={":pk":P(t.pKey,t.pKeyType),...t.sKey&&{":sk":P(t.sKey,t.sKeyType??"S")},...t.skValue2&&{":skValue2":P(t.skValue2,t.sKeyType??"S")},...e.extraExpAttributeValues||{}},u=e.queryRequest.lastEvaluatedKey&&Object.keys(e.queryRequest.lastEvaluatedKey).length>0?e.queryRequest.lastEvaluatedKey:void 0;return {TableName:e.tableName,IndexName:t.indexName,KeyConditionExpression:r,FilterExpression:e.filterExpression,ExpressionAttributeNames:s,ExpressionAttributeValues:p,ProjectionExpression:n,ScanIndexForward:t.sorting!==void 0?t.sorting.toUpperCase()==="ASC":e.scanIndexForward,ReturnConsumedCapacity:e.returnConsumedCapacity,ExclusiveStartKey:u,Limit:t.limit}}function X(e){try{if(!e||e.length===0)return null;let t={},r={},n=[],s=u=>`#f${u}`,p=(u,o)=>`:f${u}${o}`;for(let u=0;u<e.length;u++){let o=e[u],m=s(u);switch(t[m]=o.name,o.condition){case "EXISTS":{n.push(`(attribute_exists(${m}))`);break}case "NOT_EXISTS":{n.push(`(attribute_not_exists(${m}))`);break}case "BEGINS_WITH":{if(o.type!=="S")throw new Error(`BEGINS_WITH is only valid for type S (filter[${u}] has type ${o.type})`);let i=p(u,"v");r[i]=y(o.type,K(o,u)),n.push(`begins_with(${m}, ${i})`);break}case "CONTAINS":{if(o.type==="SS"||o.type==="NS"){let i=o.values;if(!Array.isArray(i)||i.length===0)throw new Error(`CONTAINS with ${o.type} requires values[] (non-empty) for filter[${u}]`);let a=[];for(let c=0;c<i.length;c++){let T=p(u,`vs${c}`);r[T]=Y(o.type,i[c]),a.push(`contains(${m}, ${T})`);}n.push(`(${a.length===1?a[0]:`(${a.join(" OR ")})`})`);}else {let i=p(u,"v");r[i]=y(o.type,o.value),n.push(`(contains(${m}, ${i}))`);}break}case "NOT_CONTAINS":{if(o.type==="SS"||o.type==="NS"){let i=o.values;if(!Array.isArray(i)||i.length===0)throw new Error(`NOT_CONTAINS with ${o.type} requires values[] (non-empty) for filter[${u}]`);let a=[];for(let c=0;c<i.length;c++){let T=p(u,`vs${c}`);r[T]=Y(o.type,i[c]),a.push(`contains(${m}, ${T})`);}n.push(`(NOT (${a.join(" OR ")}))`);}else {let i=p(u,"v");r[i]=y(o.type,K(o,u)),n.push(`NOT contains(${m}, ${i})`);}break}case "BETWEEN":{if(typeof o.value!="string"||typeof o.value2!="string")throw new Error(`BETWEEN requires value and value2 for filter[${u}]`);if(o.type==="SS"||o.type==="NS"||o.type==="BOOL"||o.type==="NULL")throw new Error(`BETWEEN is not valid for type ${o.type} (filter[${u}])`);let i=p(u,"v"),a=p(u,"v2");r[i]=y(o.type,o.value),r[a]=y(o.type,o.value2),n.push(`(${m} BETWEEN ${i} AND ${a})`);break}case "EQUAL_TO":case "NOT_EQUAL_TO":case "LESS_THAN":case "LESS_THAN_OR_EQUAL_TO":case "GREATER_THAN":case "GREATER_THAN_OR_EQUAL_TO":{if(o.type==="SS"||o.type==="NS")throw new Error(`Comparator "${o.condition}" is not supported for ${o.type}; use CONTAINS/NOT_CONTAINS`);let i=p(u,"v");r[i]=y(o.type,K(o,u));let a=o.condition==="EQUAL_TO"?"=":o.condition==="NOT_EQUAL_TO"?"<>":o.condition==="LESS_THAN"?"<":o.condition==="LESS_THAN_OR_EQUAL_TO"?"<=":o.condition==="GREATER_THAN"?">":">=";n.push(`(${m} ${a} ${i})`);break}default:{let i=o.condition;throw new Error(`Unsupported filter condition: ${String(i)}`)}}}return {filterExpression:n.join(" AND "),expressionAttributeNames:t,expressionAttributeValues:r}}catch(t){throw console.error("Error generating DynamoDB filter attributes:",t),t}}function y(e,t){switch(e){case "S":return t;case "N":{let r=Number(t);if(!Number.isFinite(r))throw new Error(`Invalid numeric value "${t}" for type N`);return r}case "BOOL":{let r=t.trim().toLowerCase();if(r==="true"||r==="1")return  true;if(r==="false"||r==="0")return  false;throw new Error(`Invalid boolean value "${t}" for type BOOL`)}case "NULL":return null;default:return t}}var Y=(e,t)=>{if(e==="SS")return t;if(e==="NS"){let r=Number(t);if(!Number.isFinite(r))throw new Error(`Invalid numeric value "${t}" for type NS element`);return r}return y(e,t)},K=(e,t)=>{if(typeof e.value!="string")throw new Error(`${e.condition} requires value for filter[${t}]`);return e.value};function ut(e){let{tableName:t,indexName:r,filtersAttributes:n,filterExpression:s,expressionAttributeNames:p,expressionAttributeValues:u,extraExpAttributeNames:o,extraExpAttributeValues:m,projectionExpression:i,limit:a,exclusiveStartKey:c,consistentRead:T,segment:R,totalSegments:C,returnConsumedCapacity:G,returnItemCollectionMetrics:v}=W.parse(e);if(n&&n.length>0)throw new d("Provide either filtersAttributes or filterExpression (not both).",400);let N={TableName:t,...r?{IndexName:r}:{},...i?{ProjectionExpression:i}:{},...a?{Limit:a}:{},...c?{ExclusiveStartKey:c}:{},...T!==void 0?{ConsistentRead:T}:{},...R!==void 0&&C!==void 0?{Segment:R,TotalSegments:C}:{},...G?{ReturnConsumedCapacity:G}:{},...v?{ReturnItemCollectionMetrics:v}:{}};if(n&&n.length>0){let x=X(n);if(!x)throw new d("Failed to generate filter expression from filtersAttributes.",400);let{filterExpression:g,expressionAttributeNames:D,expressionAttributeValues:b}=x;if(!g)throw new d("Generated filterExpression is empty.",400);return N.FilterExpression=g,N.ExpressionAttributeNames=F(D,o),N.ExpressionAttributeValues=M(b,m),N}if(s){N.FilterExpression=s;let x=s.includes("#"),g=s.includes(":"),D=F(p,o),b=M(u,m);if(x&&!z(D))throw new d("filterExpression contains name placeholders (#) but ExpressionAttributeNames is missing.",400);if(g&&!z(b))throw new d("filterExpression contains value placeholders (:) but ExpressionAttributeValues is missing.",400);return N.ExpressionAttributeNames=D,N.ExpressionAttributeValues=b,N}return N.ExpressionAttributeNames=F(p,o),N.ExpressionAttributeValues=M(u,m),N.ExpressionAttributeNames&&Object.keys(N.ExpressionAttributeNames).length===0&&delete N.ExpressionAttributeNames,N.ExpressionAttributeValues&&Object.keys(N.ExpressionAttributeValues).length===0&&delete N.ExpressionAttributeValues,N}function M(e,t){if(!(!e&&!t))return {...e??{},...t??{}}}function F(e,t){if(!(!e&&!t))return {...e??{},...t??{}}}function z(e){return !!e&&typeof e=="object"&&!Array.isArray(e)&&Object.keys(e).length>0}function ct(e){let t={TableName:e.tableName,Key:e.key,ConditionExpression:e.conditionExpression,ReturnValues:e.returnValues??"NONE",ReturnConsumedCapacity:e.returnConsumedCapacity,ReturnItemCollectionMetrics:e.returnItemCollectionMetrics},r={},n={};if(e.expressionAttributeNames)for(let a in e.expressionAttributeNames)r[a]=e.expressionAttributeNames[a];if(e.extraExpAttributeNames)for(let a in e.extraExpAttributeNames)r[a]=e.extraExpAttributeNames[a];if(e.expressionAttributeValues)for(let a in e.expressionAttributeValues)n[a]=e.expressionAttributeValues[a];if(e.extraExpAttributeValues)for(let a in e.extraExpAttributeValues)n[a]=e.extraExpAttributeValues[a];let s=e.updateExpression;if(s)return Object.keys(r).length>0&&(t.ExpressionAttributeNames=r),Object.keys(n).length>0&&(t.ExpressionAttributeValues=n),t.UpdateExpression=s,t;let p=e.item;if(!p||Object.keys(p).length===0)throw new Error("Either updateExpression or item with at least one field must be provided.");let u=[],o=p;for(let a in o){let c=o[a],T=`:${a}`;if(n[T]!==void 0){let R=1,C;do C=`:${a}_update_${R++}`;while(n[C]!==void 0);T=C;}u.push(`${a} = ${T}`),n[T]=c;}let m=`SET ${u.join(", ")}`;s=Q(m);let i=j(s);for(let a in i)a in r||(r[a]=i[a]);return Object.keys(r).length>0&&(t.ExpressionAttributeNames=r),Object.keys(n).length>0&&(t.ExpressionAttributeValues=n),t.UpdateExpression=s,t}exports.QueryParseError=d;exports.RESERVED_KEYWORDS_SET=q;exports.buildGetCommandInput=je;exports.buildPutCommandInput=Ye;exports.buildQueryCommandInput=Je;exports.buildScanCommandInput=ut;exports.buildUpdateCommandInput=ct;exports.createKeyConditionExpression=B;exports.customGetCommandInputSchema=de;exports.customPutCommandInputSchema=Se;exports.customQueryCommandInputSchema=Ie;exports.customScanCommandInputSch=W;exports.customUpdateCommandInputSchema=Re;exports.dynamoAttrTypeSch=pe;exports.dynamoComparatorSch=Z;exports.dynamoFilterConditionSch=re;exports.dynamoFilterSch=ne;exports.dynamoFilterValueTypeSch=te;exports.dynamoFiltersInputSch=H;exports.dynamoKeyAttrTypeSch=w;exports.dynamoQueryRequestSch=h;exports.extractExpAttributeNamesFromExpression=O;exports.extractExpAttributeNamesFromUpdateExp=j;exports.extractQueryReqFromParams=be;exports.generateDynamoFilterAttributes=X;exports.omit=Fe;exports.parseDynamoKeyValue=P;exports.parseValueByType=y;exports.replaceReservedKeywordsFromProjection=V;exports.replaceReservedKeywordsFromUpdateExp=Q;

package/dist/index.mjs

@@ -1 +1 @@
-import {z}from'zod';function x(e){let{sKey:t,skValue2:s,skComparator:o}=e,n="#pk = :pk";if(!t&&!s)return n;switch(b(o??"=")){case "<":n+=" AND #sk < :sk";break;case ">":n+=" AND #sk > :sk";break;case "<=":n+=" AND #sk <= :sk";break;case ">=":n+=" AND #sk >= :sk";break;case "BEGINS_WITH":if(!s)throw new Error("BEGINS_WITH operation requires skValue2.");n+=" AND begins_with(#sk, :skValue2)";break;case "BETWEEN":if(!t||!s)throw new Error("BETWEEN operation requires both sk and skValue2.");n+=" AND #sk BETWEEN :sk AND :skValue2";break;default:n+=" AND #sk = :sk";break}return n}function b(e){switch(e.toUpperCase()){case "BETWEEN":return "BETWEEN";case "BEGINS_WITH":return "BEGINS_WITH";case "GREATER_THAN":case ">":return ">";case "LESS_THAN":case "<":return "<";case "GREATER_THAN_OR_EQUAL":case ">=":return ">=";case "LESS_THAN_OR_EQUAL":case "<=":return "<=";case "EQUAL":case "=":return "=";default:throw new Error(`Invalid operation key: ${e}`)}}var l=class extends Error{constructor(t,s=400){super(t),this.name="QueryParseError",this.statusCode=s;}},D=l;var W=z.enum(["S","N","B","BOOL","NULL","SS","NS","BS","M","L"]),U=z.enum(["S","N","B"]),k=z.enum(["=","<","<=",">",">=","BETWEEN","BEGINS_WITH"]),P=z.preprocess(e=>typeof e=="string"?e.trim():e,z.string().min(1)),C=z.preprocess(e=>{if(!(e===""||e===null||e===void 0))return typeof e=="string"?e.trim():e},z.string().optional()),V=z.preprocess(e=>{if(!(e===""||e===null||e===void 0)){if(typeof e=="object")return e;if(typeof e=="string"){let t=e.trim();if(!t)return;try{return JSON.parse(t)}catch{return t}}return e}},z.record(z.string(),z.unknown()).optional()),c=z.object({pKey:P,pKeyType:U,pKeyProp:P,sKey:C,sKeyType:U.optional(),sKeyProp:C,skValue2:C,skComparator:k.optional(),indexName:C,limit:z.coerce.number().int().positive().optional(),lastEvaluatedKey:V,sorting:z.enum(["ASC","DESC"]).optional()}).superRefine((e,t)=>{typeof e.lastEvaluatedKey=="string"&&t.addIssue({path:["lastEvaluatedKey"],code:"custom",message:"lastEvaluatedKey must be a JSON object or a stringified JSON object"}),e.skComparator?(e.sKey||t.addIssue({path:["sKey"],code:"custom",message:"sKey is required when skComparator is present"}),e.sKeyProp||t.addIssue({path:["sKeyProp"],code:"custom",message:"sKeyProp is required when skComparator is present"}),e.sKeyType||t.addIssue({path:["sKeyType"],code:"custom",message:"sKeyType is required when skComparator is present"}),e.skComparator==="BETWEEN"?e.skValue2||t.addIssue({path:["skValue2"],code:"custom",message:"skValue2 is required when skComparator is BETWEEN"}):e.skValue2&&t.addIssue({path:["skValue2"],code:"custom",message:"skValue2/skValue2Type are only allowed when skComparator is BETWEEN"})):(e.sKey||e.sKeyProp||e.sKeyType||e.skValue2)&&t.addIssue({path:["skComparator"],code:"custom",message:"skComparator is required when providing sort key conditions"});});var O=z.enum(["INDEXES","TOTAL","NONE"]),f=z.enum(["SIZE","NONE"]),q=z.object({tableName:z.string(),key:z.record(z.string(),z.unknown()),projectionExpression:z.string().optional(),expressionAttributeNames:z.record(z.string(),z.string()).optional(),consistentRead:z.boolean().optional(),returnConsumedCapacity:O.optional()}),X=z.object({tableName:z.string(),queryRequest:c,keyConditionExpression:z.string().optional(),filterExpression:z.string().optional(),expressionAttributeNames:z.record(z.string(),z.string()).optional(),expressionAttributeValues:z.record(z.string(),z.unknown()).optional(),extraExpAttributeNames:z.record(z.string(),z.string()).optional(),extraExpAttributeValues:z.record(z.string(),z.unknown()).optional(),projectionExpression:z.string().optional(),scanIndexForward:z.boolean().optional(),returnConsumedCapacity:O.optional()}),_=z.object({tableName:z.string(),item:z.record(z.string(),z.unknown()),conditionExpression:z.string().optional(),expressionAttributeNames:z.record(z.string(),z.string()).optional(),expressionAttributeValues:z.record(z.string(),z.unknown()).optional(),returnValues:z.enum(["NONE","ALL_OLD","UPDATED_OLD","ALL_NEW","UPDATED_NEW"]).optional(),returnConsumedCapacity:O.optional(),returnItemCollectionMetrics:f.optional()}),v=z.object({tableName:z.string(),key:z.record(z.string(),z.unknown()),item:z.record(z.string(),z.unknown()).optional(),updateExpression:z.string().optional(),conditionExpression:z.string().optional(),expressionAttributeNames:z.record(z.string(),z.string()).optional(),expressionAttributeValues:z.record(z.string(),z.unknown()).optional(),extraExpAttributeNames:z.record(z.string(),z.string()).optional(),extraExpAttributeValues:z.record(z.string(),z.unknown()).optional(),returnValues:z.enum(["NONE","ALL_OLD","UPDATED_OLD","ALL_NEW","UPDATED_NEW"]).optional(),returnConsumedCapacity:O.optional(),returnItemCollectionMetrics:f.optional()});function oe(e,t){let s=e||{},o={...s,indexName:s.indexName??s.index},n=o.indexName,i=typeof o.pKey=="string"&&o.pKey.trim().length>0;return n?n===t.indexName?A(i?{...o,indexName:t.indexName}:{indexName:t.indexName,pKey:o.pKey||t.pKey,pKeyType:o.pKeyType||t.pKeyType,pKeyProp:o.pKeyProp||t.pKeyProp,limit:Number(o.limit||t.limit||"10"),sKey:o.sKey||t.sKey,sKeyType:o.sKeyType||t.sKeyType,sKeyProp:o.sKeyProp||t.sKeyProp,skValue2:o.skValue2||t.skValue2,skComparator:o.skComparator||t.skComparator,lastEvaluatedKey:o.lastEvaluatedKey||t.lastEvaluatedKey,sorting:o.sorting||t.sorting}):A(o):A(i?o:{...t,...o,indexName:t.indexName})}function A(e){let t=c.safeParse(e);if(!t.success){let s=t.error.issues.map(o=>`${o.path}: ${o.message}`).join(", ");throw new D(`Bad request! ${s}`,400)}return t.data}function d(e,t){switch(t){case "S":return e;case "N":return Number(e);case "BOOL":return e.toLowerCase()==="true";case "NULL":return null;case "M":try{return JSON.parse(e)}catch{throw new Error("Invalid JSON format for partitionKeyType M (Map)")}case "L":try{return JSON.parse(e)}catch{throw new Error("Invalid JSON format for partitionKeyType L (List)")}case "SS":return e.split(",").map(s=>s.trim());case "NS":return e.split(",").map(s=>Number(s.trim())).filter(s=>!isNaN(s));case "BS":return e.split(",").map(s=>Buffer.from(s.trim(),"base64"));default:throw new Error(`Unsupported partitionKeyType: ${t}`)}}function I(e){let t={};for(let s of e.split(",")){let o=s.trim();o.startsWith("#")&&(t[o]=o.slice(1));}return t}function g(e){let t={},s=e.replace(/^\s*SET\s+/i,"").trim();if(!s)return t;let o=s.split(",");for(let n of o){let i=n.split("=")[0]?.trim();!i||!i.startsWith("#")||(t[i]=i.slice(1));}return t}var K=new Set(["ABORT","ABSOLUTE","ACTION","ADD","AFTER","AGENT","AGGREGATE","ALL","ALLOCATE","ALTER","ANALYZE","AND","ANY","ARCHIVE","ARE","ARRAY","AS","ASC","ASCII","ASENSITIVE","ASSERTION","ASYMMETRIC","AT","ATOMIC","ATTACH","ATTRIBUTE","AUTH","AUTHORIZATION","AUTHORIZE","AUTO","AVG","BACK","BACKUP","BASE","BATCH","BEFORE","BEGIN","BETWEEN","BIGINT","BINARY","BIT","BLOB","BLOCK","BOOLEAN","BOTH","BREADTH","BUCKET","BULK","BY","BYTE","CALL","CALLED","CALLING","CAPACITY","CASCADE","CASCADED","CASE","CAST","CATALOG","CHAR","CHARACTER","CHECK","CLASS","CLOB","CLOSE","CLUSTER","CLUSTERED","CLUSTERING","CLUSTERS","COALESCE","COLLATE","COLLATION","COLLECTION","COLUMN","COLUMNS","COMBINE","COMMENT","COMMIT","COMPACT","COMPILE","COMPRESS","CONDITION","CONFLICT","CONNECT","CONNECTION","CONSISTENCY","CONSISTENT","CONSTRAINT","CONSTRUCTOR","CONSUMED","CONTINUE","CONVERT","COPY","CORRESPONDING","COUNT","COUNTER","CREATE","CROSS","CSV","CUBE","CURRENT","CURSOR","CYCLE","DATA","DATABASE","DATE","DATETIME","DAY","DEALLOCATE","DEC","DECIMAL","DECLARE","DEFAULT","DEFERRABLE","DEFERRED","DEFINE","DEFINED","DEFINITION","DELETE","DELIMITED","DEPTH","DEREF","DESC","DESCRIBE","DESCRIPTOR","DETACH","DETERMINISTIC","DIAGNOSTICS","DIRECTORIES","DISABLE","DISCONNECT","DISTINCT","DISTRIBUTE","DO","DOMAIN","DOUBLE","DROP","DUMP","DURATION","DYNAMIC","EACH","ELEMENT","ELSE","ELSEIF","EMPTY","ENABLE","END","EQUAL","EQUALS","ERROR","ESCAPE","ESCAPED","EVAL","EVALUATE","EXCEEDED","EXCEPT","EXCEPTIONS","EXCLUSIVE","EXEC","EXECUTE","EXISTS","EXIT","EXPLAIN","EXPLODE","EXPORT","EXPRESSION","EXTENDED","EXTERNAL","EXTRACT","FAIL","FALSE","FAMILY","FETCH","FIELDS","FILE","FILTER","FILTERING","FINAL","FINISH","FIRST","FIXED","FLATTERN","FLOAT","FOR","FORCE","FOREIGN","FORMAT","FORWARD","FOUND","FREE","FROM","FULL","FUNCTION","FUNCTIONS","GENERAL","GENERATE","GET","GLOB","GLOBAL","GO","GOTO","GRANT","GROUP","GROUPING","HANDLER","HASH","HAVE","HAVING","HEAP","HIDDEN","HOLD","HOUR","IDENTIFIED","IDENTITY","IF","IGNORE","IMMEDIATE","IMPORT","IN","INCLUDING","INCLUSIVE","INCREMENT","INDEX","INDEXED","INDEXES","INET","INF","INFINITE","INITIALLY","INLINE","INNER","INNTER","INPUT","INSENSITIVE","INSERT","INSTEAD","INT","INTEGER","INTERSECT","INTERVAL","INTO","INVALIDATE","IS","ISOLATION","ITEM","ITEMS","ITERATE","JOIN","KEY","KEYS","LAG","LANGUAGE","LARGE","LAST","LATERAL","LEAD","LEADING","LEAVE","LEFT","LEVEL","LIKE","LIMIT","LIMITED","LINES","LIST","LOAD","LOCAL","LOCALTIME","LOCALTIMESTAMP","LOCATION","LOCATOR","LOCK","LOCKS","LOG","LOGED","LONG","LOOP","LOW","MAP","MATCH","MATERIALIZED","MAX","MAXLEN","MEMBER","MERGE","METHOD","MIN","MINUS","MINUTE","MISSING","MOD","MODE","MODIFIES","MODIFY","MODULE","MONTH","MULTI","MULTISET","NAME","NAMES","NATIONAL","NATURAL","NCHAR","NCLOB","NEW","NEXT","NO","NONE","NOT","NULL","NULLIF","NUMBER","NUMERIC","OBJECT","OF","OFFLINE","OFFSET","OLD","ON","ONLINE","ONLY","OPAQUE","OPEN","OPERATOR","OPTION","OR","ORDER","ORDINALITY","OUT","OUTER","OUTPUT","OVER","OVERLAPS","OVERRIDE","PARTITION","PARTITIONED","PARTITIONS","PATH","PERCENT","PERCENTILE","PERMISSION","PERMISSIONS","PIPE","PIPELINED","PLAN","POOL","POSITION","PRECISION","PREPARE","PRESERVE","PRIMARY","PRIOR","PRIVATE","PRIVILEGES","PROCEDURE","PROCESSED","PROJECT","PROJECTION","PROPERTY","PROVISIONING","PUBLIC","PUT","QUERY","QUIT","QUORUM","RAISE","RANGE","RANK","RAW","READ","READS","REAL","REBUILD","RECORD","RECURSIVE","REDUCE","REF","REFERENCE","REFERENCES","REFERENCING","REGEXP","REGION","REINDEX","RELATIVE","RELEASE","REMA","REMAINDER","RENAME","REPEAT","REPLACE","REQUEST","RESET","RESIGNAL","RESOURCE","RESPONSE","RESTORE","RESTRICT","RESULT","RETURN","RETURNING","REVEAL","REVERSE","REVOKE","RIGHT","ROLE","ROLES","ROLLBACK","ROLLUP","ROUTINE","ROW","ROWS","RULE","RULES","SAMPLE","SATISFIES","SAVE","SAVEPOINT","SCAN","SCHEMA","SCOPE","SCROLL","SEARCH","SECOND","SECTION","SEGMENT","SEGMENTS","SELECT","SELF","SEMI","SENSITIVE","SEPARATE","SEQUENCE","SERIALIZABLE","SESSION","SET","SETS","SHARD","SHARE","SHARED","SHORT","SHOW","SIGNAL","SIMILAR","SIZE","SKEWED","SMALLINT","SNAPSHOT","SOME","SOURCE","SPACE","SPLIT","SQL","SQLCODE","SQLERROR","SQLEXCEPTION","SQLSTATE","SQLWARNING","START","STATE","STATIC","STATUS","STORAGE","STORE","STORED","STREAM","STRING","STRUCT","STYLE","SUB","SUBMULTISET","SUBPARTITION","SUBSTRING","SUBTYPE","SUM","SUPER","SYMMETRIC","SYNONYM","SYSTEM","TABLE","TABLESAMPLE","TEMP","TEMPORARY","TERMINATED","TEXT","THAN","THEN","THROUGHPUT","TIME","TIMESTAMP","TIMEZONE","TINYINT","TO","TOKEN","TOTAL","TOUCH","TRAILING","TRAN","TRANSACTION","TRANSFORM","TRANSLATE","TRANSLATION","TREAT","TRIGGER","TRIM","TRUE","TRUNCATE","TTL","TUPLE","TYPE","UNDER","UNDO","UNION","UNIQUE","UNIT","UNKNOWN","UNLOGGED","UNNEST","UNPROCESSED","UNSIGNED","UNTIL","UPDATE","UPPER","URL","USAGE","USE","USING","UUID","VACUUM","VALUE","VALUED","VALUES","VARCHAR","VARIABLE","VARIANCE","VARINT","VARYING","VIEW","VIEWS","VIRTUAL","VOID","WAIT","WHEN","WHENEVER","WHERE","WHILE","WINDOW","WITH","WITHIN","WITHOUT","WORK","WRAPPED","WRITE","YEAR","ZONE"]),G=new RegExp(`\\b(?:${[...K].join("|")})\\b(?=\\s*=)`,"gi");function M(e){return e.replace(G,t=>`#${t}`)}function L(e){return e.split(",").map(t=>{let s=t.trim();return s&&(K.has(s.toUpperCase())?`#${s}`:s)}).join(", ")}function Se(e){let{tableName:t,key:s,projectionExpression:o,expressionAttributeNames:n,consistentRead:i,returnConsumedCapacity:u}=e,m=o?L(o):void 0,T={TableName:t,Key:s,ProjectionExpression:m,ConsistentRead:i,ReturnConsumedCapacity:u},p={...m?I(m):{},...n??{}};return Object.keys(p).length>0&&(T.ExpressionAttributeNames=p),T}function Oe(e){let{tableName:t,item:s,conditionExpression:o,expressionAttributeNames:n,expressionAttributeValues:i,returnValues:u="NONE",returnConsumedCapacity:m,returnItemCollectionMetrics:T}=e,p={TableName:t,Item:s,ConditionExpression:o,ReturnValues:u,ReturnConsumedCapacity:m,ReturnItemCollectionMetrics:T},E=!!o,R=!!n&&Object.keys(n).length>0;if(E||R){let N=E?I(o):{},S=R?{...N,...n}:N;Object.keys(S).length>0&&(p.ExpressionAttributeNames=S);}return i&&Object.keys(i).length>0&&(p.ExpressionAttributeValues=i),p}function ye(e){let{queryRequest:t}=e,s=x(t),o=e.projectionExpression?L(e.projectionExpression):void 0,n={"#pk":t.pKeyProp,...t.sKeyProp&&{"#sk":t.sKeyProp},...o&&I(o),...e.extraExpAttributeNames||{}},i={":pk":d(t.pKey,t.pKeyType),...t.sKey&&{":sk":d(t.sKey,t.sKeyType??"S")},...t.skValue2&&{":skValue2":d(t.skValue2,t.sKeyType??"S")},...e.extraExpAttributeValues||{}};return {TableName:e.tableName,IndexName:t.indexName,KeyConditionExpression:s,FilterExpression:e.filterExpression,ExpressionAttributeNames:n,ExpressionAttributeValues:i,ProjectionExpression:o,ScanIndexForward:t.sorting!==void 0?t.sorting.toUpperCase()==="ASC":e.scanIndexForward,ReturnConsumedCapacity:e.returnConsumedCapacity,ExclusiveStartKey:t.lastEvaluatedKey,Limit:t.limit}}function xe(e){let t={TableName:e.tableName,Key:e.key,ConditionExpression:e.conditionExpression,ReturnValues:e.returnValues??"NONE",ReturnConsumedCapacity:e.returnConsumedCapacity,ReturnItemCollectionMetrics:e.returnItemCollectionMetrics},s={},o={};if(e.expressionAttributeNames)for(let E in e.expressionAttributeNames)s[E]=e.expressionAttributeNames[E];if(e.extraExpAttributeNames)for(let E in e.extraExpAttributeNames)s[E]=e.extraExpAttributeNames[E];if(e.expressionAttributeValues)for(let E in e.expressionAttributeValues)o[E]=e.expressionAttributeValues[E];if(e.extraExpAttributeValues)for(let E in e.extraExpAttributeValues)o[E]=e.extraExpAttributeValues[E];let n=e.updateExpression;if(n)return Object.keys(s).length>0&&(t.ExpressionAttributeNames=s),Object.keys(o).length>0&&(t.ExpressionAttributeValues=o),t.UpdateExpression=n,t;let i=e.item;if(!i||Object.keys(i).length===0)throw new Error("Either updateExpression or item with at least one field must be provided.");let u=[],m=i;for(let E in m){let R=m[E],N=`:${E}`;if(o[N]!==void 0){let S=1,y;do y=`:${E}_update_${S++}`;while(o[y]!==void 0);N=y;}u.push(`${E} = ${N}`),o[N]=R;}let T=`SET ${u.join(", ")}`;n=M(T);let p=g(n);for(let E in p)E in s||(s[E]=p[E]);return Object.keys(s).length>0&&(t.ExpressionAttributeNames=s),Object.keys(o).length>0&&(t.ExpressionAttributeValues=o),t.UpdateExpression=n,t}export{D as QueryParseError,K as RESERVED_KEYWORDS_SET,Se as buildGetCommandInput,Oe as buildPutCommandInput,ye as buildQueryCommandInput,xe as buildUpdateCommandInput,x as createKeyConditionExpression,q as customGetCommandInputSchema,_ as customPutCommandInputSchema,X as customQueryCommandInputSchema,v as customUpdateCommandInputSchema,W as dynamoAttrTypeSch,k as dynamoComparatorSch,U as dynamoKeyAttrTypeSch,c as dynamoQueryRequestSch,I as extractExpAttributeNamesFromExpression,g as extractExpAttributeNamesFromUpdateExp,oe as extractQueryReqFromParams,d as parseDynamoKeyValue,L as replaceReservedKeywordsFromProjection,M as replaceReservedKeywordsFromUpdateExp};
+import {z as z$1}from'zod';function B(e){let{sKey:t,skValue2:r,skComparator:n}=e,s="#pk = :pk";if(!t&&!r)return s;switch(J(n??"=")){case "<":s+=" AND #sk < :sk";break;case ">":s+=" AND #sk > :sk";break;case "<=":s+=" AND #sk <= :sk";break;case ">=":s+=" AND #sk >= :sk";break;case "BEGINS_WITH":if(!r)throw new Error("BEGINS_WITH operation requires skValue2.");s+=" AND begins_with(#sk, :skValue2)";break;case "BETWEEN":if(!t||!r)throw new Error("BETWEEN operation requires both sk and skValue2.");s+=" AND #sk BETWEEN :sk AND :skValue2";break;default:s+=" AND #sk = :sk";break}return s}function J(e){switch(e.toUpperCase()){case "BETWEEN":return "BETWEEN";case "BEGINS_WITH":return "BEGINS_WITH";case "GREATER_THAN":case ">":return ">";case "LESS_THAN":case "<":return "<";case "GREATER_THAN_OR_EQUAL":case ">=":return ">=";case "LESS_THAN_OR_EQUAL":case "<=":return "<=";case "EQUAL":case "=":return "=";default:throw new Error(`Invalid operation key: ${e}`)}}var k=class extends Error{constructor(t,r=400){super(t),this.name="QueryParseError",this.statusCode=r;}},d=k;var pe=z$1.enum(["S","N","B","BOOL","NULL","SS","NS","BS","M","L"]),w=z$1.enum(["S","N","B"]),Z=z$1.enum(["=","<","<=",">",">=","BETWEEN","BEGINS_WITH"]),_=z$1.preprocess(e=>typeof e=="string"?e.trim():e,z$1.string().min(1)),U=z$1.preprocess(e=>{if(!(e===""||e===null||e===void 0))return typeof e=="string"?e.trim():e},z$1.string().optional()),ee=z$1.preprocess(e=>{if(!(e===""||e===null||e===void 0)){if(typeof e=="object")return e;if(typeof e=="string"){let t=e.trim();if(!t)return;try{return JSON.parse(t)}catch{return t}}return e}},z$1.record(z$1.string(),z$1.unknown()).optional()),h=z$1.object({pKey:_,pKeyType:w,pKeyProp:_,sKey:U,sKeyType:w.optional(),sKeyProp:U,skValue2:U,skComparator:Z.optional(),indexName:U,limit:z$1.coerce.number().int().positive().optional(),lastEvaluatedKey:ee,sorting:z$1.enum(["ASC","DESC"]).optional()}).superRefine((e,t)=>{typeof e.lastEvaluatedKey=="string"&&t.addIssue({path:["lastEvaluatedKey"],code:"custom",message:"lastEvaluatedKey must be a JSON object or a stringified JSON object"}),e.skComparator?(e.sKey||t.addIssue({path:["sKey"],code:"custom",message:"sKey is required when skComparator is present"}),e.sKeyProp||t.addIssue({path:["sKeyProp"],code:"custom",message:"sKeyProp is required when skComparator is present"}),e.sKeyType||t.addIssue({path:["sKeyType"],code:"custom",message:"sKeyType is required when skComparator is present"}),e.skComparator==="BETWEEN"?e.skValue2||t.addIssue({path:["skValue2"],code:"custom",message:"skValue2 is required when skComparator is BETWEEN"}):e.skValue2&&t.addIssue({path:["skValue2"],code:"custom",message:"skValue2/skValue2Type are only allowed when skComparator is BETWEEN"})):(e.sKey||e.sKeyProp||e.sKeyType||e.skValue2)&&t.addIssue({path:["skComparator"],code:"custom",message:"skComparator is required when providing sort key conditions"});});var te=z$1.enum(["S","N","BOOL","NULL","SS","NS"]),re=z$1.enum(["EQUAL_TO","NOT_EQUAL_TO","LESS_THAN","LESS_THAN_OR_EQUAL_TO","GREATER_THAN","GREATER_THAN_OR_EQUAL_TO","EXISTS","NOT_EXISTS","BEGINS_WITH","CONTAINS","NOT_CONTAINS","BETWEEN"]),ne=z$1.object({name:z$1.string().min(1),type:te,condition:re,value:z$1.string().optional(),value2:z$1.string().optional(),values:z$1.array(z$1.string().min(1)).min(1).optional()}).superRefine((e,t)=>{let r=typeof e.value=="string",n=typeof e.value2=="string",s=Array.isArray(e.values)&&e.values.length>0;if(e.condition==="EXISTS"||e.condition==="NOT_EXISTS"){(r||n||s)&&t.addIssue({code:"custom",path:["condition"],message:`${e.condition} must not include value/value2/values`});return}if(e.condition==="BETWEEN"){r||t.addIssue({code:"custom",path:["value"],message:"BETWEEN requires value"}),n||t.addIssue({code:"custom",path:["value2"],message:"BETWEEN requires value2"}),s&&t.addIssue({code:"custom",path:["values"],message:"BETWEEN must not include values"});return}if(e.type==="SS"||e.type==="NS"){s||t.addIssue({code:"custom",path:["values"],message:`${e.type} filter requires values (non-empty)`}),(r||n)&&t.addIssue({code:"custom",path:["type"],message:`${e.type} filter must not include value/value2; use values`});return}r||t.addIssue({code:"custom",path:["value"],message:`${e.condition} requires value`}),n&&t.addIssue({code:"custom",path:["value2"],message:`${e.condition} must not include value2`}),s&&t.addIssue({code:"custom",path:["values"],message:`${e.condition} must not include values`});}),H=z$1.array(ne).max(50);var f=z$1.enum(["INDEXES","TOTAL","NONE"]),$=z$1.enum(["SIZE","NONE"]),A=z$1.record(z$1.string(),z$1.unknown()),S=z$1.record(z$1.string(),z$1.string()),de=z$1.object({tableName:z$1.string(),key:A,projectionExpression:z$1.string().optional(),expressionAttributeNames:S.optional(),consistentRead:z$1.boolean().optional(),returnConsumedCapacity:f.optional()}),Ie=z$1.object({tableName:z$1.string(),queryRequest:h,keyConditionExpression:z$1.string().optional(),filterExpression:z$1.string().optional(),expressionAttributeNames:S.optional(),expressionAttributeValues:A.optional(),extraExpAttributeNames:S.optional(),extraExpAttributeValues:A.optional(),projectionExpression:z$1.string().optional(),scanIndexForward:z$1.boolean().optional(),returnConsumedCapacity:f.optional()}),Se=z$1.object({tableName:z$1.string(),item:A,conditionExpression:z$1.string().optional(),expressionAttributeNames:S.optional(),expressionAttributeValues:A.optional(),returnValues:z$1.enum(["NONE","ALL_OLD","UPDATED_OLD","ALL_NEW","UPDATED_NEW"]).optional(),returnConsumedCapacity:f.optional(),returnItemCollectionMetrics:$.optional()}),Re=z$1.object({tableName:z$1.string(),key:A,item:A.optional(),updateExpression:z$1.string().optional(),conditionExpression:z$1.string().optional(),expressionAttributeNames:S.optional(),expressionAttributeValues:A.optional(),extraExpAttributeNames:S.optional(),extraExpAttributeValues:A.optional(),returnValues:z$1.enum(["NONE","ALL_OLD","UPDATED_OLD","ALL_NEW","UPDATED_NEW"]).optional(),returnConsumedCapacity:f.optional(),returnItemCollectionMetrics:$.optional()}),W=z$1.object({tableName:z$1.string(),indexName:z$1.string().optional(),filtersAttributes:H.optional(),filterExpression:z$1.string().optional(),projectionExpression:z$1.string().optional(),expressionAttributeNames:S.optional(),expressionAttributeValues:A.optional(),extraExpAttributeNames:S.optional(),extraExpAttributeValues:A.optional(),limit:z$1.number().int().positive().optional(),exclusiveStartKey:A.optional(),consistentRead:z$1.boolean().optional(),segment:z$1.number().int().nonnegative().optional(),totalSegments:z$1.number().int().positive().optional(),returnConsumedCapacity:f.optional(),returnItemCollectionMetrics:z$1.enum(["SIZE","NONE"]).optional()}).superRefine((e,t)=>{let r=e.segment!==void 0,n=e.totalSegments!==void 0;r!==n&&t.addIssue({code:"custom",message:"segment and totalSegments must be provided together for parallel scan.",path:r?["totalSegments"]:["segment"]}),r&&n&&(e.totalSegments<=0&&t.addIssue({code:"custom",message:"totalSegments must be > 0.",path:["totalSegments"]}),(e.segment<0||e.segment>=e.totalSegments)&&t.addIssue({code:"custom",message:"segment must be in range [0, totalSegments-1].",path:["segment"]})),e.indexName&&e.consistentRead===true&&t.addIssue({code:"custom",message:"consistentRead cannot be true when scanning a GSI (indexName provided).",path:["consistentRead"]});});function be(e,t){let r=e||{},n={...r,indexName:r.indexName??r.index},s=n.indexName,p=typeof n.pKey=="string"&&n.pKey.trim().length>0;return s?s===t.indexName?L(p?{...n,indexName:t.indexName}:{indexName:t.indexName,pKey:n.pKey||t.pKey,pKeyType:n.pKeyType||t.pKeyType,pKeyProp:n.pKeyProp||t.pKeyProp,limit:Number(n.limit||t.limit||"10"),sKey:n.sKey||t.sKey,sKeyType:n.sKeyType||t.sKeyType,sKeyProp:n.sKeyProp||t.sKeyProp,skValue2:n.skValue2||t.skValue2,skComparator:n.skComparator||t.skComparator,lastEvaluatedKey:n.lastEvaluatedKey||t.lastEvaluatedKey,sorting:n.sorting||t.sorting}):L(n):L(p?n:{...t,...n,indexName:t.indexName})}function L(e){let t=h.safeParse(e);if(!t.success){let r=t.error.issues.map(n=>`${n.path}: ${n.message}`).join(", ");throw new d(`Bad request! ${r}`,400)}return t.data}function P(e,t){switch(t){case "S":return e;case "N":return Number(e);case "BOOL":return e.toLowerCase()==="true";case "NULL":return null;case "M":try{return JSON.parse(e)}catch{throw new Error("Invalid JSON format for partitionKeyType M (Map)")}case "L":try{return JSON.parse(e)}catch{throw new Error("Invalid JSON format for partitionKeyType L (List)")}case "SS":return e.split(",").map(r=>r.trim());case "NS":return e.split(",").map(r=>Number(r.trim())).filter(r=>!isNaN(r));case "BS":return e.split(",").map(r=>Buffer.from(r.trim(),"base64"));default:throw new Error(`Unsupported partitionKeyType: ${t}`)}}function O(e){let t={};for(let r of e.split(",")){let n=r.trim();n.startsWith("#")&&(t[n]=n.slice(1));}return t}function j(e){let t={},r=e.replace(/^\s*SET\s+/i,"").trim();if(!r)return t;let n=r.split(",");for(let s of n){let p=s.split("=")[0]?.trim();!p||!p.startsWith("#")||(t[p]=p.slice(1));}return t}var q=new Set(["ABORT","ABSOLUTE","ACTION","ADD","AFTER","AGENT","AGGREGATE","ALL","ALLOCATE","ALTER","ANALYZE","AND","ANY","ARCHIVE","ARE","ARRAY","AS","ASC","ASCII","ASENSITIVE","ASSERTION","ASYMMETRIC","AT","ATOMIC","ATTACH","ATTRIBUTE","AUTH","AUTHORIZATION","AUTHORIZE","AUTO","AVG","BACK","BACKUP","BASE","BATCH","BEFORE","BEGIN","BETWEEN","BIGINT","BINARY","BIT","BLOB","BLOCK","BOOLEAN","BOTH","BREADTH","BUCKET","BULK","BY","BYTE","CALL","CALLED","CALLING","CAPACITY","CASCADE","CASCADED","CASE","CAST","CATALOG","CHAR","CHARACTER","CHECK","CLASS","CLOB","CLOSE","CLUSTER","CLUSTERED","CLUSTERING","CLUSTERS","COALESCE","COLLATE","COLLATION","COLLECTION","COLUMN","COLUMNS","COMBINE","COMMENT","COMMIT","COMPACT","COMPILE","COMPRESS","CONDITION","CONFLICT","CONNECT","CONNECTION","CONSISTENCY","CONSISTENT","CONSTRAINT","CONSTRUCTOR","CONSUMED","CONTINUE","CONVERT","COPY","CORRESPONDING","COUNT","COUNTER","CREATE","CROSS","CSV","CUBE","CURRENT","CURSOR","CYCLE","DATA","DATABASE","DATE","DATETIME","DAY","DEALLOCATE","DEC","DECIMAL","DECLARE","DEFAULT","DEFERRABLE","DEFERRED","DEFINE","DEFINED","DEFINITION","DELETE","DELIMITED","DEPTH","DEREF","DESC","DESCRIBE","DESCRIPTOR","DETACH","DETERMINISTIC","DIAGNOSTICS","DIRECTORIES","DISABLE","DISCONNECT","DISTINCT","DISTRIBUTE","DO","DOMAIN","DOUBLE","DROP","DUMP","DURATION","DYNAMIC","EACH","ELEMENT","ELSE","ELSEIF","EMPTY","ENABLE","END","EQUAL","EQUALS","ERROR","ESCAPE","ESCAPED","EVAL","EVALUATE","EXCEEDED","EXCEPT","EXCEPTIONS","EXCLUSIVE","EXEC","EXECUTE","EXISTS","EXIT","EXPLAIN","EXPLODE","EXPORT","EXPRESSION","EXTENDED","EXTERNAL","EXTRACT","FAIL","FALSE","FAMILY","FETCH","FIELDS","FILE","FILTER","FILTERING","FINAL","FINISH","FIRST","FIXED","FLATTERN","FLOAT","FOR","FORCE","FOREIGN","FORMAT","FORWARD","FOUND","FREE","FROM","FULL","FUNCTION","FUNCTIONS","GENERAL","GENERATE","GET","GLOB","GLOBAL","GO","GOTO","GRANT","GROUP","GROUPING","HANDLER","HASH","HAVE","HAVING","HEAP","HIDDEN","HOLD","HOUR","IDENTIFIED","IDENTITY","IF","IGNORE","IMMEDIATE","IMPORT","IN","INCLUDING","INCLUSIVE","INCREMENT","INDEX","INDEXED","INDEXES","INET","INF","INFINITE","INITIALLY","INLINE","INNER","INNTER","INPUT","INSENSITIVE","INSERT","INSTEAD","INT","INTEGER","INTERSECT","INTERVAL","INTO","INVALIDATE","IS","ISOLATION","ITEM","ITEMS","ITERATE","JOIN","KEY","KEYS","LAG","LANGUAGE","LARGE","LAST","LATERAL","LEAD","LEADING","LEAVE","LEFT","LEVEL","LIKE","LIMIT","LIMITED","LINES","LIST","LOAD","LOCAL","LOCALTIME","LOCALTIMESTAMP","LOCATION","LOCATOR","LOCK","LOCKS","LOG","LOGED","LONG","LOOP","LOW","MAP","MATCH","MATERIALIZED","MAX","MAXLEN","MEMBER","MERGE","METHOD","MIN","MINUS","MINUTE","MISSING","MOD","MODE","MODIFIES","MODIFY","MODULE","MONTH","MULTI","MULTISET","NAME","NAMES","NATIONAL","NATURAL","NCHAR","NCLOB","NEW","NEXT","NO","NONE","NOT","NULL","NULLIF","NUMBER","NUMERIC","OBJECT","OF","OFFLINE","OFFSET","OLD","ON","ONLINE","ONLY","OPAQUE","OPEN","OPERATOR","OPTION","OR","ORDER","ORDINALITY","OUT","OUTER","OUTPUT","OVER","OVERLAPS","OVERRIDE","PARTITION","PARTITIONED","PARTITIONS","PATH","PERCENT","PERCENTILE","PERMISSION","PERMISSIONS","PIPE","PIPELINED","PLAN","POOL","POSITION","PRECISION","PREPARE","PRESERVE","PRIMARY","PRIOR","PRIVATE","PRIVILEGES","PROCEDURE","PROCESSED","PROJECT","PROJECTION","PROPERTY","PROVISIONING","PUBLIC","PUT","QUERY","QUIT","QUORUM","RAISE","RANGE","RANK","RAW","READ","READS","REAL","REBUILD","RECORD","RECURSIVE","REDUCE","REF","REFERENCE","REFERENCES","REFERENCING","REGEXP","REGION","REINDEX","RELATIVE","RELEASE","REMA","REMAINDER","RENAME","REPEAT","REPLACE","REQUEST","RESET","RESIGNAL","RESOURCE","RESPONSE","RESTORE","RESTRICT","RESULT","RETURN","RETURNING","REVEAL","REVERSE","REVOKE","RIGHT","ROLE","ROLES","ROLLBACK","ROLLUP","ROUTINE","ROW","ROWS","RULE","RULES","SAMPLE","SATISFIES","SAVE","SAVEPOINT","SCAN","SCHEMA","SCOPE","SCROLL","SEARCH","SECOND","SECTION","SEGMENT","SEGMENTS","SELECT","SELF","SEMI","SENSITIVE","SEPARATE","SEQUENCE","SERIALIZABLE","SESSION","SET","SETS","SHARD","SHARE","SHARED","SHORT","SHOW","SIGNAL","SIMILAR","SIZE","SKEWED","SMALLINT","SNAPSHOT","SOME","SOURCE","SPACE","SPLIT","SQL","SQLCODE","SQLERROR","SQLEXCEPTION","SQLSTATE","SQLWARNING","START","STATE","STATIC","STATUS","STORAGE","STORE","STORED","STREAM","STRING","STRUCT","STYLE","SUB","SUBMULTISET","SUBPARTITION","SUBSTRING","SUBTYPE","SUM","SUPER","SYMMETRIC","SYNONYM","SYSTEM","TABLE","TABLESAMPLE","TEMP","TEMPORARY","TERMINATED","TEXT","THAN","THEN","THROUGHPUT","TIME","TIMESTAMP","TIMEZONE","TINYINT","TO","TOKEN","TOTAL","TOUCH","TRAILING","TRAN","TRANSACTION","TRANSFORM","TRANSLATE","TRANSLATION","TREAT","TRIGGER","TRIM","TRUE","TRUNCATE","TTL","TUPLE","TYPE","UNDER","UNDO","UNION","UNIQUE","UNIT","UNKNOWN","UNLOGGED","UNNEST","UNPROCESSED","UNSIGNED","UNTIL","UPDATE","UPPER","URL","USAGE","USE","USING","UUID","VACUUM","VALUE","VALUED","VALUES","VARCHAR","VARIABLE","VARIANCE","VARINT","VARYING","VIEW","VIEWS","VIRTUAL","VOID","WAIT","WHEN","WHENEVER","WHERE","WHILE","WINDOW","WITH","WITHIN","WITHOUT","WORK","WRAPPED","WRITE","YEAR","ZONE"]),oe=new RegExp(`\\b(?:${[...q].join("|")})\\b(?=\\s*=)`,"gi");function Q(e){return e.replace(oe,t=>`#${t}`)}function V(e){return e.split(",").map(t=>{let r=t.trim();return r&&(q.has(r.toUpperCase())?`#${r}`:r)}).join(", ")}function Fe(e,t){let r={};for(let n in e)Object.prototype.hasOwnProperty.call(e,n)&&!t.includes(n)&&(r[n]=e[n]);return r}function je(e){let{tableName:t,key:r,projectionExpression:n,expressionAttributeNames:s,consistentRead:p,returnConsumedCapacity:u}=e,o=n?V(n):void 0,m={TableName:t,Key:r,ProjectionExpression:o,ConsistentRead:p,ReturnConsumedCapacity:u},i={...o?O(o):{},...s??{}};return Object.keys(i).length>0&&(m.ExpressionAttributeNames=i),m}function Ye(e){let{tableName:t,item:r,conditionExpression:n,expressionAttributeNames:s,expressionAttributeValues:p,returnValues:u="NONE",returnConsumedCapacity:o,returnItemCollectionMetrics:m}=e,i={TableName:t,Item:r,ConditionExpression:n,ReturnValues:u,ReturnConsumedCapacity:o,ReturnItemCollectionMetrics:m},a=!!n,c=!!s&&Object.keys(s).length>0;if(a||c){let T=a?O(n):{},R=c?{...T,...s}:T;Object.keys(R).length>0&&(i.ExpressionAttributeNames=R);}return p&&Object.keys(p).length>0&&(i.ExpressionAttributeValues=p),i}function Je(e){let{queryRequest:t}=e,r=B(t),n=e.projectionExpression?V(e.projectionExpression):void 0,s={"#pk":t.pKeyProp,...t.sKeyProp&&{"#sk":t.sKeyProp},...n&&O(n),...e.extraExpAttributeNames||{}},p={":pk":P(t.pKey,t.pKeyType),...t.sKey&&{":sk":P(t.sKey,t.sKeyType??"S")},...t.skValue2&&{":skValue2":P(t.skValue2,t.sKeyType??"S")},...e.extraExpAttributeValues||{}},u=e.queryRequest.lastEvaluatedKey&&Object.keys(e.queryRequest.lastEvaluatedKey).length>0?e.queryRequest.lastEvaluatedKey:void 0;return {TableName:e.tableName,IndexName:t.indexName,KeyConditionExpression:r,FilterExpression:e.filterExpression,ExpressionAttributeNames:s,ExpressionAttributeValues:p,ProjectionExpression:n,ScanIndexForward:t.sorting!==void 0?t.sorting.toUpperCase()==="ASC":e.scanIndexForward,ReturnConsumedCapacity:e.returnConsumedCapacity,ExclusiveStartKey:u,Limit:t.limit}}function X(e){try{if(!e||e.length===0)return null;let t={},r={},n=[],s=u=>`#f${u}`,p=(u,o)=>`:f${u}${o}`;for(let u=0;u<e.length;u++){let o=e[u],m=s(u);switch(t[m]=o.name,o.condition){case "EXISTS":{n.push(`(attribute_exists(${m}))`);break}case "NOT_EXISTS":{n.push(`(attribute_not_exists(${m}))`);break}case "BEGINS_WITH":{if(o.type!=="S")throw new Error(`BEGINS_WITH is only valid for type S (filter[${u}] has type ${o.type})`);let i=p(u,"v");r[i]=y(o.type,K(o,u)),n.push(`begins_with(${m}, ${i})`);break}case "CONTAINS":{if(o.type==="SS"||o.type==="NS"){let i=o.values;if(!Array.isArray(i)||i.length===0)throw new Error(`CONTAINS with ${o.type} requires values[] (non-empty) for filter[${u}]`);let a=[];for(let c=0;c<i.length;c++){let T=p(u,`vs${c}`);r[T]=Y(o.type,i[c]),a.push(`contains(${m}, ${T})`);}n.push(`(${a.length===1?a[0]:`(${a.join(" OR ")})`})`);}else {let i=p(u,"v");r[i]=y(o.type,o.value),n.push(`(contains(${m}, ${i}))`);}break}case "NOT_CONTAINS":{if(o.type==="SS"||o.type==="NS"){let i=o.values;if(!Array.isArray(i)||i.length===0)throw new Error(`NOT_CONTAINS with ${o.type} requires values[] (non-empty) for filter[${u}]`);let a=[];for(let c=0;c<i.length;c++){let T=p(u,`vs${c}`);r[T]=Y(o.type,i[c]),a.push(`contains(${m}, ${T})`);}n.push(`(NOT (${a.join(" OR ")}))`);}else {let i=p(u,"v");r[i]=y(o.type,K(o,u)),n.push(`NOT contains(${m}, ${i})`);}break}case "BETWEEN":{if(typeof o.value!="string"||typeof o.value2!="string")throw new Error(`BETWEEN requires value and value2 for filter[${u}]`);if(o.type==="SS"||o.type==="NS"||o.type==="BOOL"||o.type==="NULL")throw new Error(`BETWEEN is not valid for type ${o.type} (filter[${u}])`);let i=p(u,"v"),a=p(u,"v2");r[i]=y(o.type,o.value),r[a]=y(o.type,o.value2),n.push(`(${m} BETWEEN ${i} AND ${a})`);break}case "EQUAL_TO":case "NOT_EQUAL_TO":case "LESS_THAN":case "LESS_THAN_OR_EQUAL_TO":case "GREATER_THAN":case "GREATER_THAN_OR_EQUAL_TO":{if(o.type==="SS"||o.type==="NS")throw new Error(`Comparator "${o.condition}" is not supported for ${o.type}; use CONTAINS/NOT_CONTAINS`);let i=p(u,"v");r[i]=y(o.type,K(o,u));let a=o.condition==="EQUAL_TO"?"=":o.condition==="NOT_EQUAL_TO"?"<>":o.condition==="LESS_THAN"?"<":o.condition==="LESS_THAN_OR_EQUAL_TO"?"<=":o.condition==="GREATER_THAN"?">":">=";n.push(`(${m} ${a} ${i})`);break}default:{let i=o.condition;throw new Error(`Unsupported filter condition: ${String(i)}`)}}}return {filterExpression:n.join(" AND "),expressionAttributeNames:t,expressionAttributeValues:r}}catch(t){throw console.error("Error generating DynamoDB filter attributes:",t),t}}function y(e,t){switch(e){case "S":return t;case "N":{let r=Number(t);if(!Number.isFinite(r))throw new Error(`Invalid numeric value "${t}" for type N`);return r}case "BOOL":{let r=t.trim().toLowerCase();if(r==="true"||r==="1")return  true;if(r==="false"||r==="0")return  false;throw new Error(`Invalid boolean value "${t}" for type BOOL`)}case "NULL":return null;default:return t}}var Y=(e,t)=>{if(e==="SS")return t;if(e==="NS"){let r=Number(t);if(!Number.isFinite(r))throw new Error(`Invalid numeric value "${t}" for type NS element`);return r}return y(e,t)},K=(e,t)=>{if(typeof e.value!="string")throw new Error(`${e.condition} requires value for filter[${t}]`);return e.value};function ut(e){let{tableName:t,indexName:r,filtersAttributes:n,filterExpression:s,expressionAttributeNames:p,expressionAttributeValues:u,extraExpAttributeNames:o,extraExpAttributeValues:m,projectionExpression:i,limit:a,exclusiveStartKey:c,consistentRead:T,segment:R,totalSegments:C,returnConsumedCapacity:G,returnItemCollectionMetrics:v}=W.parse(e);if(n&&n.length>0)throw new d("Provide either filtersAttributes or filterExpression (not both).",400);let N={TableName:t,...r?{IndexName:r}:{},...i?{ProjectionExpression:i}:{},...a?{Limit:a}:{},...c?{ExclusiveStartKey:c}:{},...T!==void 0?{ConsistentRead:T}:{},...R!==void 0&&C!==void 0?{Segment:R,TotalSegments:C}:{},...G?{ReturnConsumedCapacity:G}:{},...v?{ReturnItemCollectionMetrics:v}:{}};if(n&&n.length>0){let x=X(n);if(!x)throw new d("Failed to generate filter expression from filtersAttributes.",400);let{filterExpression:g,expressionAttributeNames:D,expressionAttributeValues:b}=x;if(!g)throw new d("Generated filterExpression is empty.",400);return N.FilterExpression=g,N.ExpressionAttributeNames=F(D,o),N.ExpressionAttributeValues=M(b,m),N}if(s){N.FilterExpression=s;let x=s.includes("#"),g=s.includes(":"),D=F(p,o),b=M(u,m);if(x&&!z(D))throw new d("filterExpression contains name placeholders (#) but ExpressionAttributeNames is missing.",400);if(g&&!z(b))throw new d("filterExpression contains value placeholders (:) but ExpressionAttributeValues is missing.",400);return N.ExpressionAttributeNames=D,N.ExpressionAttributeValues=b,N}return N.ExpressionAttributeNames=F(p,o),N.ExpressionAttributeValues=M(u,m),N.ExpressionAttributeNames&&Object.keys(N.ExpressionAttributeNames).length===0&&delete N.ExpressionAttributeNames,N.ExpressionAttributeValues&&Object.keys(N.ExpressionAttributeValues).length===0&&delete N.ExpressionAttributeValues,N}function M(e,t){if(!(!e&&!t))return {...e??{},...t??{}}}function F(e,t){if(!(!e&&!t))return {...e??{},...t??{}}}function z(e){return !!e&&typeof e=="object"&&!Array.isArray(e)&&Object.keys(e).length>0}function ct(e){let t={TableName:e.tableName,Key:e.key,ConditionExpression:e.conditionExpression,ReturnValues:e.returnValues??"NONE",ReturnConsumedCapacity:e.returnConsumedCapacity,ReturnItemCollectionMetrics:e.returnItemCollectionMetrics},r={},n={};if(e.expressionAttributeNames)for(let a in e.expressionAttributeNames)r[a]=e.expressionAttributeNames[a];if(e.extraExpAttributeNames)for(let a in e.extraExpAttributeNames)r[a]=e.extraExpAttributeNames[a];if(e.expressionAttributeValues)for(let a in e.expressionAttributeValues)n[a]=e.expressionAttributeValues[a];if(e.extraExpAttributeValues)for(let a in e.extraExpAttributeValues)n[a]=e.extraExpAttributeValues[a];let s=e.updateExpression;if(s)return Object.keys(r).length>0&&(t.ExpressionAttributeNames=r),Object.keys(n).length>0&&(t.ExpressionAttributeValues=n),t.UpdateExpression=s,t;let p=e.item;if(!p||Object.keys(p).length===0)throw new Error("Either updateExpression or item with at least one field must be provided.");let u=[],o=p;for(let a in o){let c=o[a],T=`:${a}`;if(n[T]!==void 0){let R=1,C;do C=`:${a}_update_${R++}`;while(n[C]!==void 0);T=C;}u.push(`${a} = ${T}`),n[T]=c;}let m=`SET ${u.join(", ")}`;s=Q(m);let i=j(s);for(let a in i)a in r||(r[a]=i[a]);return Object.keys(r).length>0&&(t.ExpressionAttributeNames=r),Object.keys(n).length>0&&(t.ExpressionAttributeValues=n),t.UpdateExpression=s,t}export{d as QueryParseError,q as RESERVED_KEYWORDS_SET,je as buildGetCommandInput,Ye as buildPutCommandInput,Je as buildQueryCommandInput,ut as buildScanCommandInput,ct as buildUpdateCommandInput,B as createKeyConditionExpression,de as customGetCommandInputSchema,Se as customPutCommandInputSchema,Ie as customQueryCommandInputSchema,W as customScanCommandInputSch,Re as customUpdateCommandInputSchema,pe as dynamoAttrTypeSch,Z as dynamoComparatorSch,re as dynamoFilterConditionSch,ne as dynamoFilterSch,te as dynamoFilterValueTypeSch,H as dynamoFiltersInputSch,w as dynamoKeyAttrTypeSch,h as dynamoQueryRequestSch,O as extractExpAttributeNamesFromExpression,j as extractExpAttributeNamesFromUpdateExp,be as extractQueryReqFromParams,X as generateDynamoFilterAttributes,Fe as omit,P as parseDynamoKeyValue,y as parseValueByType,V as replaceReservedKeywordsFromProjection,Q as replaceReservedKeywordsFromUpdateExp};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dynamo-command-builder",
-  "version": "0.1.7",
+  "version": "0.2.2",
   "description": "A dynamo command builder wrapper for AWS DynamoDB SDK v3, written in TypeScript.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",