dynamo-command-builder 0.1.1 → 0.1.3

package/dist/index.mjs

@@ -1,1031 +1 @@
-import { z } from 'zod';
-
-// src/utils/query-request/comparator.ts
-function createKeyConditionExpression(queryRequest) {
-  const { sKey, skValue2, skComparator } = queryRequest;
-  let keyConditionExpression = "#pk = :pk";
-  if (!sKey && !skValue2) return keyConditionExpression;
-  switch (getOperatorSymbolByKey(skComparator ?? "=")) {
-    case "<":
-      keyConditionExpression += " AND #sk < :sk";
-      break;
-    case ">":
-      keyConditionExpression += " AND #sk > :sk";
-      break;
-    case "<=":
-      keyConditionExpression += " AND #sk <= :sk";
-      break;
-    case ">=":
-      keyConditionExpression += " AND #sk >= :sk";
-      break;
-    case "BEGINS_WITH":
-      if (!skValue2) throw new Error("BEGINS_WITH operation requires skValue2.");
-      keyConditionExpression += ` AND begins_with(#sk, :skValue2)`;
-      break;
-    case "BETWEEN":
-      if (!sKey || !skValue2) throw new Error("BETWEEN operation requires both sk and skValue2.");
-      keyConditionExpression += " AND #sk BETWEEN :sk AND :skValue2";
-      break;
-    default:
-      keyConditionExpression += " AND #sk = :sk";
-      break;
-  }
-  return keyConditionExpression;
-}
-function getOperatorSymbolByKey(operation) {
-  switch (operation.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: ${operation}`);
-  }
-}
-
-// src/utils/dynamo-value-parse.ts
-function parseDynamoKeyValue(key, keyType) {
-  switch (keyType) {
-    case "S":
-      return key;
-    case "N":
-      return Number(key);
-    case "BOOL":
-      return key.toLowerCase() === "true";
-    case "NULL":
-      return null;
-    case "M":
-      try {
-        return JSON.parse(key);
-      } catch {
-        throw new Error("Invalid JSON format for partitionKeyType M (Map)");
-      }
-    case "L":
-      try {
-        return JSON.parse(key);
-      } catch {
-        throw new Error("Invalid JSON format for partitionKeyType L (List)");
-      }
-    case "SS":
-      return key.split(",").map((item) => item.trim());
-    case "NS":
-      return key.split(",").map((item) => Number(item.trim())).filter((num) => !isNaN(num));
-    case "BS":
-      return key.split(",").map((item) => Buffer.from(item.trim(), "base64"));
-    default:
-      throw new Error(`Unsupported partitionKeyType: ${keyType}`);
-  }
-}
-
-// src/utils/expression-attribute-names.ts
-function extractExpAttributeNamesFromExpression(expression) {
-  const result = {};
-  for (const raw of expression.split(",")) {
-    const attr = raw.trim();
-    if (attr.startsWith("#")) {
-      result[attr] = attr.slice(1);
-    }
-  }
-  return result;
-}
-function extractExpAttributeNamesFromUpdateExp(expression) {
-  const result = {};
-  const body = expression.replace(/^\s*SET\s+/i, "").trim();
-  if (!body) return result;
-  const assignments = body.split(",");
-  for (const assignment of assignments) {
-    const leftSide = assignment.split("=")[0]?.trim();
-    if (!leftSide || !leftSide.startsWith("#")) continue;
-    result[leftSide] = leftSide.slice(1);
-  }
-  return result;
-}
-
-// src/utils/reserved-keywords.ts
-var RESERVED_KEYWORDS_SET = /* @__PURE__ */ 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"
-]);
-var UPDATE_RESERVED_REGEX = new RegExp(`\\b(?:${[...RESERVED_KEYWORDS_SET].join("|")})\\b(?=\\s*=)`, "gi");
-function replaceReservedKeywordsFromUpdateExp(updateExpression) {
-  return updateExpression.replace(UPDATE_RESERVED_REGEX, (match) => `#${match}`);
-}
-function replaceReservedKeywordsFromProjection(projection) {
-  return projection.split(",").map((item) => {
-    const trimmed = item.trim();
-    if (!trimmed) return trimmed;
-    return RESERVED_KEYWORDS_SET.has(trimmed.toUpperCase()) ? `#${trimmed}` : trimmed;
-  }).join(", ");
-}
-
-// src/command/build-get-command.ts
-function buildGetCommandInput(input) {
-  const {
-    tableName: TableName,
-    // The name of the DynamoDB table
-    key: Key,
-    // The key of the item to retrieve
-    projectionExpression,
-    // Optional: Specifies attributes to retrieve
-    expressionAttributeNames: extraExpressionAttributesNames,
-    // Additional expression attribute names
-    consistentRead: ConsistentRead,
-    // Optional: Specifies whether to use strongly consistent reads
-    returnConsumedCapacity: ReturnConsumedCapacity
-    // Optional: Determines whether to return consumed capacity
-  } = input;
-  const ProjectionExpression = projectionExpression ? replaceReservedKeywordsFromProjection(projectionExpression) : void 0;
-  const commandInput = {
-    TableName,
-    Key,
-    ProjectionExpression,
-    ConsistentRead,
-    ReturnConsumedCapacity
-  };
-  const expressionAttributeNames = {
-    ...ProjectionExpression ? extractExpAttributeNamesFromExpression(ProjectionExpression) : {},
-    ...extraExpressionAttributesNames ?? {}
-  };
-  if (Object.keys(expressionAttributeNames).length > 0) {
-    commandInput.ExpressionAttributeNames = expressionAttributeNames;
-  }
-  return commandInput;
-}
-
-// src/command/build-put-command.ts
-function buildPutCommandInput(input) {
-  const {
-    tableName,
-    item,
-    conditionExpression,
-    expressionAttributeNames,
-    expressionAttributeValues,
-    returnValues = "NONE",
-    returnConsumedCapacity,
-    returnItemCollectionMetrics
-  } = input;
-  const commandInput = {
-    TableName: tableName,
-    Item: item,
-    ConditionExpression: conditionExpression,
-    ReturnValues: returnValues,
-    ReturnConsumedCapacity: returnConsumedCapacity,
-    ReturnItemCollectionMetrics: returnItemCollectionMetrics
-  };
-  const hasCondition = !!conditionExpression;
-  const hasProvidedNames = !!expressionAttributeNames && Object.keys(expressionAttributeNames).length > 0;
-  if (hasCondition || hasProvidedNames) {
-    const generatedNames = hasCondition ? extractExpAttributeNamesFromExpression(conditionExpression) : {};
-    const mergedNames = hasProvidedNames ? { ...generatedNames, ...expressionAttributeNames } : generatedNames;
-    if (Object.keys(mergedNames).length > 0) {
-      commandInput.ExpressionAttributeNames = mergedNames;
-    }
-  }
-  if (expressionAttributeValues && Object.keys(expressionAttributeValues).length > 0) {
-    commandInput.ExpressionAttributeValues = expressionAttributeValues;
-  }
-  return commandInput;
-}
-
-// src/command/build-query-command.ts
-function buildQueryCommandInput(input) {
-  const { queryRequest } = input;
-  const KeyConditionExpression = createKeyConditionExpression(queryRequest);
-  const ProjectionExpression = input.projectionExpression ? replaceReservedKeywordsFromProjection(input.projectionExpression) : void 0;
-  const ExpressionAttributeNames = {
-    "#pk": queryRequest.pKeyProp,
-    ...queryRequest.sKeyProp && { "#sk": queryRequest.sKeyProp },
-    ...ProjectionExpression && extractExpAttributeNamesFromExpression(ProjectionExpression),
-    ...input.extraExpAttributeNames || {}
-  };
-  const ExpressionAttributeValues = {
-    ":pk": parseDynamoKeyValue(queryRequest.pKey, queryRequest.pKeyType),
-    ...queryRequest.sKey && {
-      ":sk": parseDynamoKeyValue(queryRequest.sKey, queryRequest.sKeyType ?? `S`)
-    },
-    ...queryRequest.skValue2 && {
-      ":skValue2": parseDynamoKeyValue(queryRequest.skValue2, queryRequest.sKeyType ?? `S`)
-    },
-    ...input.extraExpAttributeValues || {}
-  };
-  const commandInput = {
-    TableName: input.tableName,
-    IndexName: queryRequest.indexName,
-    KeyConditionExpression,
-    FilterExpression: input.filterExpression,
-    ExpressionAttributeNames,
-    ExpressionAttributeValues,
-    ProjectionExpression,
-    ScanIndexForward: queryRequest.sorting !== void 0 ? queryRequest.sorting.toUpperCase() === "ASC" : input.scanIndexForward,
-    ReturnConsumedCapacity: input.returnConsumedCapacity,
-    ExclusiveStartKey: queryRequest.lastEvaluatedKey,
-    Limit: queryRequest.limit
-  };
-  return commandInput;
-}
-
-// src/command/build-update-command.ts
-function buildUpdateCommandInput(input) {
-  const commandInput = {
-    TableName: input.tableName,
-    Key: input.key,
-    ConditionExpression: input.conditionExpression,
-    ReturnValues: input.returnValues ?? "NONE",
-    ReturnConsumedCapacity: input.returnConsumedCapacity,
-    ReturnItemCollectionMetrics: input.returnItemCollectionMetrics
-  };
-  const names = {};
-  const values = {};
-  if (input.expressionAttributeNames) {
-    for (const key in input.expressionAttributeNames) {
-      names[key] = input.expressionAttributeNames[key];
-    }
-  }
-  if (input.extraExpAttributeNames) {
-    for (const key in input.extraExpAttributeNames) {
-      names[key] = input.extraExpAttributeNames[key];
-    }
-  }
-  if (input.expressionAttributeValues) {
-    for (const key in input.expressionAttributeValues) {
-      values[key] = input.expressionAttributeValues[key];
-    }
-  }
-  if (input.extraExpAttributeValues) {
-    for (const key in input.extraExpAttributeValues) {
-      values[key] = input.extraExpAttributeValues[key];
-    }
-  }
-  let updateExpression = input.updateExpression;
-  if (updateExpression) {
-    if (Object.keys(names).length > 0) {
-      commandInput.ExpressionAttributeNames = names;
-    }
-    if (Object.keys(values).length > 0) {
-      commandInput.ExpressionAttributeValues = values;
-    }
-    commandInput.UpdateExpression = updateExpression;
-    return commandInput;
-  }
-  const item = input.item;
-  if (!item || Object.keys(item).length === 0) {
-    throw new Error("Either updateExpression or item with at least one field must be provided.");
-  }
-  const updateParts = [];
-  const itemRecord = item;
-  for (const field in itemRecord) {
-    const value = itemRecord[field];
-    let valueKey = `:${field}`;
-    if (values[valueKey] !== void 0) {
-      let counter = 1;
-      let candidate;
-      do {
-        candidate = `:${field}_update_${counter++}`;
-      } while (values[candidate] !== void 0);
-      valueKey = candidate;
-    }
-    updateParts.push(`${field} = ${valueKey}`);
-    values[valueKey] = value;
-  }
-  const rawExpression = `SET ${updateParts.join(", ")}`;
-  updateExpression = replaceReservedKeywordsFromUpdateExp(rawExpression);
-  const autoNames = extractExpAttributeNamesFromUpdateExp(updateExpression);
-  for (const key in autoNames) {
-    if (!(key in names)) {
-      names[key] = autoNames[key];
-    }
-  }
-  if (Object.keys(names).length > 0) {
-    commandInput.ExpressionAttributeNames = names;
-  }
-  if (Object.keys(values).length > 0) {
-    commandInput.ExpressionAttributeValues = values;
-  }
-  commandInput.UpdateExpression = updateExpression;
-  return commandInput;
-}
-var dynamoAttrTypeSch = z.enum(["S", "N", "B", "BOOL", "NULL", "SS", "NS", "BS", "M", "L"]);
-var dynamoKeyAttrTypeSch = z.enum(["S", "N", "B"]);
-var dynamoComparatorSch = z.enum(["=", "<", "<=", ">", ">=", "BETWEEN", "BEGINS_WITH"]);
-var qpStringReq = z.preprocess((v) => typeof v === "string" ? v.trim() : v, z.string().min(1));
-var qpStringOpt = z.preprocess((v) => {
-  if (v === "" || v === null || v === void 0) return void 0;
-  return typeof v === "string" ? v.trim() : v;
-}, z.string().optional());
-var dynamoLastEvaluatedKeySch = z.preprocess((raw) => {
-  if (raw === "" || raw === null || raw === void 0) return void 0;
-  if (typeof raw === "object") return raw;
-  if (typeof raw === "string") {
-    const s = raw.trim();
-    if (!s) return void 0;
-    try {
-      return JSON.parse(s);
-    } catch {
-      return s;
-    }
-  }
-  return raw;
-}, z.record(z.string(), z.unknown()).optional());
-var dynamoQueryRequestSch = z.object({
-  pKey: qpStringReq,
-  pKeyType: dynamoKeyAttrTypeSch,
-  pKeyProp: qpStringReq,
-  sKey: qpStringOpt,
-  sKeyType: dynamoKeyAttrTypeSch.optional(),
-  sKeyProp: qpStringOpt,
-  skValue2: qpStringOpt,
-  skValue2Type: dynamoKeyAttrTypeSch.optional(),
-  skComparator: dynamoComparatorSch.optional(),
-  indexName: qpStringOpt,
-  limit: z.coerce.number().int().positive().optional(),
-  lastEvaluatedKey: dynamoLastEvaluatedKeySch,
-  sorting: z.enum(["ASC", "DESC"]).optional()
-}).superRefine((data, ctx) => {
-  if (typeof data.lastEvaluatedKey === "string") {
-    ctx.addIssue({
-      path: ["lastEvaluatedKey"],
-      code: z.ZodIssueCode.custom,
-      message: "lastEvaluatedKey must be a JSON object or a stringified JSON object"
-    });
-  }
-  if (data.skComparator) {
-    if (!data.sKey) {
-      ctx.addIssue({
-        path: ["sKey"],
-        code: z.ZodIssueCode.custom,
-        message: "sKey is required when skComparator is present"
-      });
-    }
-    if (!data.sKeyProp) {
-      ctx.addIssue({
-        path: ["sKeyProp"],
-        code: z.ZodIssueCode.custom,
-        message: "sKeyProp is required when skComparator is present"
-      });
-    }
-    if (!data.sKeyType) {
-      ctx.addIssue({
-        path: ["sKeyType"],
-        code: z.ZodIssueCode.custom,
-        message: "sKeyType is required when skComparator is present"
-      });
-    }
-    if (data.skComparator === "BETWEEN") {
-      if (!data.skValue2) {
-        ctx.addIssue({
-          path: ["skValue2"],
-          code: z.ZodIssueCode.custom,
-          message: "skValue2 is required when skComparator is BETWEEN"
-        });
-      }
-      if (!data.skValue2Type) {
-        ctx.addIssue({
-          path: ["skValue2Type"],
-          code: z.ZodIssueCode.custom,
-          message: "skValue2Type is required when skComparator is BETWEEN"
-        });
-      }
-    } else {
-      if (data.skValue2 || data.skValue2Type) {
-        ctx.addIssue({
-          path: ["skValue2"],
-          code: z.ZodIssueCode.custom,
-          message: "skValue2/skValue2Type are only allowed when skComparator is BETWEEN"
-        });
-      }
-    }
-  } else {
-    const anySkStuff = data.sKey || data.sKeyProp || data.sKeyType || data.skValue2 || data.skValue2Type;
-    if (anySkStuff) {
-      ctx.addIssue({
-        path: ["skComparator"],
-        code: z.ZodIssueCode.custom,
-        message: "skComparator is required when providing sort key conditions"
-      });
-    }
-  }
-});
-
-// src/types/command.types.ts
-var returnConsumedCapacityOptionsSchema = z.enum(["INDEXES", "TOTAL", "NONE"]);
-var returnItemCollectionMetricsOptionsSchema = z.enum(["SIZE", "NONE"]);
-var customGetCommandInputSchema = 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: returnConsumedCapacityOptionsSchema.optional()
-});
-var customQueryCommandInputSchema = z.object({
-  tableName: z.string(),
-  queryRequest: dynamoQueryRequestSch,
-  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: returnConsumedCapacityOptionsSchema.optional()
-});
-var customPutCommandInputSchema = 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: returnConsumedCapacityOptionsSchema.optional(),
-  returnItemCollectionMetrics: returnItemCollectionMetricsOptionsSchema.optional()
-});
-var customUpdateCommandInputSchema = 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(),
-  // Overwrite ExpressionAttributeNames
-  expressionAttributeValues: z.record(z.string(), z.unknown()).optional(),
-  // Overwrite ExpressionAttributeValues
-  extraExpAttributeNames: z.record(z.string(), z.string()).optional(),
-  // Add ExpressionAttributeNames without overwriting existing ones
-  extraExpAttributeValues: z.record(z.string(), z.unknown()).optional(),
-  // Add ExpressionAttributeValues without overwriting existing ones
-  returnValues: z.enum(["NONE", "ALL_OLD", "UPDATED_OLD", "ALL_NEW", "UPDATED_NEW"]).optional(),
-  returnConsumedCapacity: returnConsumedCapacityOptionsSchema.optional(),
-  returnItemCollectionMetrics: returnItemCollectionMetricsOptionsSchema.optional()
-});
-
-export { RESERVED_KEYWORDS_SET, buildGetCommandInput, buildPutCommandInput, buildQueryCommandInput, buildUpdateCommandInput, createKeyConditionExpression, customGetCommandInputSchema, customPutCommandInputSchema, customQueryCommandInputSchema, customUpdateCommandInputSchema, dynamoAttrTypeSch, dynamoComparatorSch, dynamoKeyAttrTypeSch, dynamoQueryRequestSch, extractExpAttributeNamesFromExpression, extractExpAttributeNamesFromUpdateExp, parseDynamoKeyValue, replaceReservedKeywordsFromProjection, replaceReservedKeywordsFromUpdateExp };
-//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map
+import {z as z$1}from'zod';function l(e){let{sKey:r,skValue2:o,skComparator:n}=e,s="#pk = :pk";if(!r&&!o)return s;switch(g(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(!o)throw new Error("BEGINS_WITH operation requires skValue2.");s+=" AND begins_with(#sk, :skValue2)";break;case "BETWEEN":if(!r||!o)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 g(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}`)}}function S(e,r){switch(r){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(o=>o.trim());case "NS":return e.split(",").map(o=>Number(o.trim())).filter(o=>!isNaN(o));case "BS":return e.split(",").map(o=>Buffer.from(o.trim(),"base64"));default:throw new Error(`Unsupported partitionKeyType: ${r}`)}}function m(e){let r={};for(let o of e.split(",")){let n=o.trim();n.startsWith("#")&&(r[n]=n.slice(1));}return r}function y(e){let r={},o=e.replace(/^\s*SET\s+/i,"").trim();if(!o)return r;let n=o.split(",");for(let s of n){let i=s.split("=")[0]?.trim();!i||!i.startsWith("#")||(r[i]=i.slice(1));}return r}var D=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"]),M=new RegExp(`\\b(?:${[...D].join("|")})\\b(?=\\s*=)`,"gi");function U(e){return e.replace(M,r=>`#${r}`)}function C(e){return e.split(",").map(r=>{let o=r.trim();return o&&(D.has(o.toUpperCase())?`#${o}`:o)}).join(", ")}function X(e){let{tableName:r,key:o,projectionExpression:n,expressionAttributeNames:s,consistentRead:i,returnConsumedCapacity:u}=e,T=n?C(n):void 0,I={TableName:r,Key:o,ProjectionExpression:T,ConsistentRead:i,ReturnConsumedCapacity:u},p={...T?m(T):{},...s??{}};return Object.keys(p).length>0&&(I.ExpressionAttributeNames=p),I}function v(e){let{tableName:r,item:o,conditionExpression:n,expressionAttributeNames:s,expressionAttributeValues:i,returnValues:u="NONE",returnConsumedCapacity:T,returnItemCollectionMetrics:I}=e,p={TableName:r,Item:o,ConditionExpression:n,ReturnValues:u,ReturnConsumedCapacity:T,ReturnItemCollectionMetrics:I},E=!!n,A=!!s&&Object.keys(s).length>0;if(E||A){let N=E?m(n):{},R=A?{...N,...s}:N;Object.keys(R).length>0&&(p.ExpressionAttributeNames=R);}return i&&Object.keys(i).length>0&&(p.ExpressionAttributeValues=i),p}function z(e){let{queryRequest:r}=e,o=l(r),n=e.projectionExpression?C(e.projectionExpression):void 0,s={"#pk":r.pKeyProp,...r.sKeyProp&&{"#sk":r.sKeyProp},...n&&m(n),...e.extraExpAttributeNames||{}},i={":pk":S(r.pKey,r.pKeyType),...r.sKey&&{":sk":S(r.sKey,r.sKeyType??"S")},...r.skValue2&&{":skValue2":S(r.skValue2,r.sKeyType??"S")},...e.extraExpAttributeValues||{}};return {TableName:e.tableName,IndexName:r.indexName,KeyConditionExpression:o,FilterExpression:e.filterExpression,ExpressionAttributeNames:s,ExpressionAttributeValues:i,ProjectionExpression:n,ScanIndexForward:r.sorting!==void 0?r.sorting.toUpperCase()==="ASC":e.scanIndexForward,ReturnConsumedCapacity:e.returnConsumedCapacity,ExclusiveStartKey:r.lastEvaluatedKey,Limit:r.limit}}function te(e){let r={TableName:e.tableName,Key:e.key,ConditionExpression:e.conditionExpression,ReturnValues:e.returnValues??"NONE",ReturnConsumedCapacity:e.returnConsumedCapacity,ReturnItemCollectionMetrics:e.returnItemCollectionMetrics},o={},n={};if(e.expressionAttributeNames)for(let E in e.expressionAttributeNames)o[E]=e.expressionAttributeNames[E];if(e.extraExpAttributeNames)for(let E in e.extraExpAttributeNames)o[E]=e.extraExpAttributeNames[E];if(e.expressionAttributeValues)for(let E in e.expressionAttributeValues)n[E]=e.expressionAttributeValues[E];if(e.extraExpAttributeValues)for(let E in e.extraExpAttributeValues)n[E]=e.extraExpAttributeValues[E];let s=e.updateExpression;if(s)return Object.keys(o).length>0&&(r.ExpressionAttributeNames=o),Object.keys(n).length>0&&(r.ExpressionAttributeValues=n),r.UpdateExpression=s,r;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=[],T=i;for(let E in T){let A=T[E],N=`:${E}`;if(n[N]!==void 0){let R=1,d;do d=`:${E}_update_${R++}`;while(n[d]!==void 0);N=d;}u.push(`${E} = ${N}`),n[N]=A;}let I=`SET ${u.join(", ")}`;s=U(I);let p=y(s);for(let E in p)E in o||(o[E]=p[E]);return Object.keys(o).length>0&&(r.ExpressionAttributeNames=o),Object.keys(n).length>0&&(r.ExpressionAttributeValues=n),r.UpdateExpression=s,r}var pe=z$1.enum(["S","N","B","BOOL","NULL","SS","NS","BS","M","L"]),L=z$1.enum(["S","N","B"]),b=z$1.enum(["=","<","<=",">",">=","BETWEEN","BEGINS_WITH"]),x=z$1.preprocess(e=>typeof e=="string"?e.trim():e,z$1.string().min(1)),c=z$1.preprocess(e=>{if(!(e===""||e===null||e===void 0))return typeof e=="string"?e.trim():e},z$1.string().optional()),k=z$1.preprocess(e=>{if(!(e===""||e===null||e===void 0)){if(typeof e=="object")return e;if(typeof e=="string"){let r=e.trim();if(!r)return;try{return JSON.parse(r)}catch{return r}}return e}},z$1.record(z$1.string(),z$1.unknown()).optional()),f=z$1.object({pKey:x,pKeyType:L,pKeyProp:x,sKey:c,sKeyType:L.optional(),sKeyProp:c,skValue2:c,skValue2Type:L.optional(),skComparator:b.optional(),indexName:c,limit:z$1.coerce.number().int().positive().optional(),lastEvaluatedKey:k,sorting:z$1.enum(["ASC","DESC"]).optional()}).superRefine((e,r)=>{typeof e.lastEvaluatedKey=="string"&&r.addIssue({path:["lastEvaluatedKey"],code:"custom",message:"lastEvaluatedKey must be a JSON object or a stringified JSON object"}),e.skComparator?(e.sKey||r.addIssue({path:["sKey"],code:"custom",message:"sKey is required when skComparator is present"}),e.sKeyProp||r.addIssue({path:["sKeyProp"],code:"custom",message:"sKeyProp is required when skComparator is present"}),e.sKeyType||r.addIssue({path:["sKeyType"],code:"custom",message:"sKeyType is required when skComparator is present"}),e.skComparator==="BETWEEN"?(e.skValue2||r.addIssue({path:["skValue2"],code:"custom",message:"skValue2 is required when skComparator is BETWEEN"}),e.skValue2Type||r.addIssue({path:["skValue2Type"],code:"custom",message:"skValue2Type is required when skComparator is BETWEEN"})):(e.skValue2||e.skValue2Type)&&r.addIssue({path:["skValue2"],code:"custom",message:"skValue2/skValue2Type are only allowed when skComparator is BETWEEN"})):(e.sKey||e.sKeyProp||e.sKeyType||e.skValue2||e.skValue2Type)&&r.addIssue({path:["skComparator"],code:"custom",message:"skComparator is required when providing sort key conditions"});});var O=z$1.enum(["INDEXES","TOTAL","NONE"]),P=z$1.enum(["SIZE","NONE"]),Ie=z$1.object({tableName:z$1.string(),key:z$1.record(z$1.string(),z$1.unknown()),projectionExpression:z$1.string().optional(),expressionAttributeNames:z$1.record(z$1.string(),z$1.string()).optional(),consistentRead:z$1.boolean().optional(),returnConsumedCapacity:O.optional()}),me=z$1.object({tableName:z$1.string(),queryRequest:f,keyConditionExpression:z$1.string().optional(),filterExpression:z$1.string().optional(),expressionAttributeNames:z$1.record(z$1.string(),z$1.string()).optional(),expressionAttributeValues:z$1.record(z$1.string(),z$1.unknown()).optional(),extraExpAttributeNames:z$1.record(z$1.string(),z$1.string()).optional(),extraExpAttributeValues:z$1.record(z$1.string(),z$1.unknown()).optional(),projectionExpression:z$1.string().optional(),scanIndexForward:z$1.boolean().optional(),returnConsumedCapacity:O.optional()}),Ae=z$1.object({tableName:z$1.string(),item:z$1.record(z$1.string(),z$1.unknown()),conditionExpression:z$1.string().optional(),expressionAttributeNames:z$1.record(z$1.string(),z$1.string()).optional(),expressionAttributeValues:z$1.record(z$1.string(),z$1.unknown()).optional(),returnValues:z$1.enum(["NONE","ALL_OLD","UPDATED_OLD","ALL_NEW","UPDATED_NEW"]).optional(),returnConsumedCapacity:O.optional(),returnItemCollectionMetrics:P.optional()}),Re=z$1.object({tableName:z$1.string(),key:z$1.record(z$1.string(),z$1.unknown()),item:z$1.record(z$1.string(),z$1.unknown()).optional(),updateExpression:z$1.string().optional(),conditionExpression:z$1.string().optional(),expressionAttributeNames:z$1.record(z$1.string(),z$1.string()).optional(),expressionAttributeValues:z$1.record(z$1.string(),z$1.unknown()).optional(),extraExpAttributeNames:z$1.record(z$1.string(),z$1.string()).optional(),extraExpAttributeValues:z$1.record(z$1.string(),z$1.unknown()).optional(),returnValues:z$1.enum(["NONE","ALL_OLD","UPDATED_OLD","ALL_NEW","UPDATED_NEW"]).optional(),returnConsumedCapacity:O.optional(),returnItemCollectionMetrics:P.optional()});export{D as RESERVED_KEYWORDS_SET,X as buildGetCommandInput,v as buildPutCommandInput,z as buildQueryCommandInput,te as buildUpdateCommandInput,l as createKeyConditionExpression,Ie as customGetCommandInputSchema,Ae as customPutCommandInputSchema,me as customQueryCommandInputSchema,Re as customUpdateCommandInputSchema,pe as dynamoAttrTypeSch,b as dynamoComparatorSch,L as dynamoKeyAttrTypeSch,f as dynamoQueryRequestSch,m as extractExpAttributeNamesFromExpression,y as extractExpAttributeNamesFromUpdateExp,S as parseDynamoKeyValue,C as replaceReservedKeywordsFromProjection,U as replaceReservedKeywordsFromUpdateExp};