dynamo-command-builder 0.1.0

package/dist/index.js

@@ -0,0 +1,992 @@
+'use strict';
+
+var zod = require('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 dynamoQueryRequestSch = zod.z.object({
+  pKey: zod.z.string(),
+  pKeyType: zod.z.string(),
+  pKeyProp: zod.z.string(),
+  sKey: zod.z.string().optional(),
+  sKeyType: zod.z.string().optional(),
+  sKeyProp: zod.z.string().optional(),
+  skValue2: zod.z.string().optional(),
+  skValue2Type: zod.z.string().optional(),
+  skComparator: zod.z.string().optional(),
+  indexName: zod.z.string().optional(),
+  limit: zod.z.number().optional(),
+  lastEvaluatedKey: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  sorting: zod.z.string().optional()
+}).superRefine((data, ctx) => {
+  if (data.skComparator) {
+    if (!data.sKey) {
+      ctx.addIssue({
+        path: ["sKey"],
+        message: "sKey is required when skComparator is present",
+        code: "invalid_type",
+        expected: "string",
+        received: typeof data.sKey
+      });
+    }
+    if (!data.sKeyProp) {
+      ctx.addIssue({
+        path: ["sKeyProp"],
+        message: "sKeyProp is required when skComparator is present",
+        code: "invalid_type",
+        expected: "string",
+        received: typeof data.sKeyProp
+      });
+    }
+    if (!data.sKeyType) {
+      ctx.addIssue({
+        path: ["sKeyType"],
+        message: "sKeyType is required when skComparator is present",
+        code: "invalid_type",
+        expected: "string",
+        received: typeof data.sKeyType
+      });
+    }
+  }
+});
+
+// src/types/command.types.ts
+var returnConsumedCapacityOptionsSchema = zod.z.enum(["INDEXES", "TOTAL", "NONE"]);
+var returnItemCollectionMetricsOptionsSchema = zod.z.enum(["SIZE", "NONE"]);
+var customGetCommandInputSchema = 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: returnConsumedCapacityOptionsSchema.optional()
+});
+var customQueryCommandInputSchema = zod.z.object({
+  tableName: zod.z.string(),
+  queryRequest: dynamoQueryRequestSch,
+  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: returnConsumedCapacityOptionsSchema.optional()
+});
+var customPutCommandInputSchema = 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: returnConsumedCapacityOptionsSchema.optional(),
+  returnItemCollectionMetrics: returnItemCollectionMetricsOptionsSchema.optional()
+});
+var customUpdateCommandInputSchema = 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(),
+  // Overwrite ExpressionAttributeNames
+  expressionAttributeValues: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  // Overwrite ExpressionAttributeValues
+  extraExpAttributeNames: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+  // Add ExpressionAttributeNames without overwriting existing ones
+  extraExpAttributeValues: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  // Add ExpressionAttributeValues without overwriting existing ones
+  returnValues: zod.z.enum(["NONE", "ALL_OLD", "UPDATED_OLD", "ALL_NEW", "UPDATED_NEW"]).optional(),
+  returnConsumedCapacity: returnConsumedCapacityOptionsSchema.optional(),
+  returnItemCollectionMetrics: returnItemCollectionMetricsOptionsSchema.optional()
+});
+
+exports.RESERVED_KEYWORDS_SET = RESERVED_KEYWORDS_SET;
+exports.buildGetCommandInput = buildGetCommandInput;
+exports.buildPutCommandInput = buildPutCommandInput;
+exports.buildQueryCommandInput = buildQueryCommandInput;
+exports.buildUpdateCommandInput = buildUpdateCommandInput;
+exports.createKeyConditionExpression = createKeyConditionExpression;
+exports.customGetCommandInputSchema = customGetCommandInputSchema;
+exports.customPutCommandInputSchema = customPutCommandInputSchema;
+exports.customQueryCommandInputSchema = customQueryCommandInputSchema;
+exports.customUpdateCommandInputSchema = customUpdateCommandInputSchema;
+exports.dynamoQueryRequestSch = dynamoQueryRequestSch;
+exports.extractExpAttributeNamesFromExpression = extractExpAttributeNamesFromExpression;
+exports.extractExpAttributeNamesFromUpdateExp = extractExpAttributeNamesFromUpdateExp;
+exports.parseDynamoKeyValue = parseDynamoKeyValue;
+exports.replaceReservedKeywordsFromProjection = replaceReservedKeywordsFromProjection;
+exports.replaceReservedKeywordsFromUpdateExp = replaceReservedKeywordsFromUpdateExp;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map