@jspreddy/torq 0.1.31

package/dist/module.js

@@ -0,0 +1,1149 @@
+import $6B8p2$lodash from "lodash";
+import $6B8p2$assert from "assert";
+
+
+// picked up from https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html
+/**
+ * These words are reserved in dynamodb and can not be used as part of expressions.
+ * If we need to use these words, then we will have to use expression attribute names concept.
+ *
+ * CASE INSENSITIVE
+ */ const $8377f7c5fcf1cce8$export$e46d647da3214494 = [
+    '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',
+    'CONSTRAINTS',
+    'CONSTRUCTOR',
+    'CONSUMED',
+    'CONTINUE',
+    'CONVERT',
+    'COPY',
+    'CORRESPONDING',
+    'COUNT',
+    'COUNTER',
+    'CREATE',
+    'CROSS',
+    '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',
+    'EXCEPTION',
+    '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',
+    'GREATER',
+    'GROUP',
+    'GROUPING',
+    'HANDLER',
+    'HASH',
+    'HAVE',
+    'HAVING',
+    'HEAP',
+    'HIDDEN',
+    'HOLD',
+    'HOUR',
+    'IDENTIFIED',
+    'IDENTITY',
+    'IF',
+    'IGNORE',
+    'IMMEDIATE',
+    'IMPORT',
+    'IN',
+    'INCLUDING',
+    'INCLUSIVE',
+    'INCREMENT',
+    'INCREMENTAL',
+    'INDEX',
+    'INDEXED',
+    'INDEXES',
+    'INDICATOR',
+    'INFINITE',
+    'INITIALLY',
+    'INLINE',
+    'INNER',
+    'INNTER',
+    'INOUT',
+    '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',
+    'LENGTH',
+    'LESS',
+    'LEVEL',
+    'LIKE',
+    'LIMIT',
+    'LIMITED',
+    'LINES',
+    'LIST',
+    'LOAD',
+    'LOCAL',
+    'LOCALTIME',
+    'LOCALTIMESTAMP',
+    'LOCATION',
+    'LOCATOR',
+    'LOCK',
+    'LOCKS',
+    'LOG',
+    'LOGED',
+    'LONG',
+    'LOOP',
+    'LOWER',
+    'MAP',
+    'MATCH',
+    'MATERIALIZED',
+    'MAX',
+    'MAXLEN',
+    'MEMBER',
+    'MERGE',
+    'METHOD',
+    'METRICS',
+    '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',
+    'OTHER',
+    'OTHERS',
+    'OUT',
+    'OUTER',
+    'OUTPUT',
+    'OVER',
+    'OVERLAPS',
+    'OVERRIDE',
+    'OWNER',
+    'PAD',
+    'PARALLEL',
+    'PARAMETER',
+    'PARAMETERS',
+    'PARTIAL',
+    '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',
+    'RANDOM',
+    'RANGE',
+    'RANK',
+    'RAW',
+    'READ',
+    'READS',
+    'REAL',
+    'REBUILD',
+    'RECORD',
+    'RECURSIVE',
+    'REDUCE',
+    'REF',
+    'REFERENCE',
+    'REFERENCES',
+    'REFERENCING',
+    'REGEXP',
+    'REGION',
+    'REINDEX',
+    'RELATIVE',
+    'RELEASE',
+    'REMAINDER',
+    'RENAME',
+    'REPEAT',
+    'REPLACE',
+    'REQUEST',
+    'RESET',
+    'RESIGNAL',
+    'RESOURCE',
+    'RESPONSE',
+    'RESTORE',
+    'RESTRICT',
+    'RESULT',
+    'RETURN',
+    'RETURNING',
+    'RETURNS',
+    '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',
+    'SPACES',
+    'SPARSE',
+    'SPECIFIC',
+    'SPECIFICTYPE',
+    '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',
+    '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',
+    'USER',
+    'USERS',
+    '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 $1ced42141bbfde9c$export$99a24bd46fd1f406 = /*#__PURE__*/ function(DdbType) {
+    DdbType["String"] = "S";
+    DdbType["StringSet"] = "SS";
+    DdbType["Number"] = "N";
+    DdbType["NumberSet"] = "NS";
+    DdbType["Binary"] = "B";
+    DdbType["BinarySet"] = "BS";
+    DdbType["Boolean"] = "BOOL";
+    DdbType["Null"] = "NULL";
+    DdbType["List"] = "L";
+    DdbType["Map"] = "M";
+    return DdbType;
+}({});
+var $1ced42141bbfde9c$export$ab5aad00225c5662 = /*#__PURE__*/ function(Operation) {
+    Operation["Eq"] = "=";
+    Operation["NotEq"] = "<>";
+    Operation["Gt"] = ">";
+    Operation["GtEq"] = ">=";
+    Operation["Lt"] = "<";
+    Operation["LtEq"] = "<=";
+    return Operation;
+}({});
+class $1ced42141bbfde9c$export$62297b13309008b2 {
+    static #_ = this.DEFAULT_LIMIT = 25;
+    get state() {
+        return {
+            tableName: this._tableName,
+            hashKey: this._hashKey,
+            rangeKey: this._rangeKey,
+            mode: this._mode,
+            selections: this._selections,
+            keys: this._keys,
+            filters: this._filters,
+            index: this._index,
+            scanForward: this._scanForward,
+            limit: this._limit,
+            count: this._count,
+            startAfter: this._startAfter,
+            consumedCapacity: this._consumedCapacity
+        };
+    }
+    constructor(table){
+        this._limit = $1ced42141bbfde9c$export$62297b13309008b2.DEFAULT_LIMIT;
+        this._count = false;
+        this._tableName = table.name;
+        this._hashKey = table.hashKey;
+        this._rangeKey = table.rangeKey;
+        // initialize here so that each query obj has its own filter list.
+        this._filters = [];
+        this._keys = [];
+        this._selections = [];
+        this._rawFilters = [];
+    }
+    select(cols) {
+        $1ced42141bbfde9c$var$throwIfModeExists(this._mode);
+        this._selections = cols;
+        this._mode = 'select';
+        return this;
+    }
+    scan(cols) {
+        $1ced42141bbfde9c$var$throwIfModeExists(this._mode);
+        this._selections = cols;
+        this._mode = 'scan';
+        return this;
+    }
+    count() {
+        $1ced42141bbfde9c$var$throwIfModeExists(this._mode);
+        this._count = true;
+        this._mode = 'count';
+        return this;
+    }
+    get where() {
+        (0, $6B8p2$assert)(this._mode !== 'scan', 'Query.where: Cannot use "where" clause with scan(), use "filter" instead.');
+        const pushRangeKey = (val, type)=>{
+            if ((0, $6B8p2$lodash).isNil(this._index)) {
+                (0, $6B8p2$assert)((0, $6B8p2$lodash).isString(this._rangeKey) && (0, $6B8p2$lodash).size(this._rangeKey) > 0, 'Query.where.range: Table does not have a rangeKey');
+                this._keys.push({
+                    key: this._rangeKey,
+                    val: val,
+                    type: type
+                });
+                return;
+            }
+            (0, $6B8p2$assert)((0, $6B8p2$lodash).isString(this._index.rangeKey) && (0, $6B8p2$lodash).size(this._index.rangeKey) > 0, 'Query.where.range: Provided Index does not have a rangeKey');
+            this._keys.push({
+                key: this._index.rangeKey,
+                val: val,
+                type: type
+            });
+        };
+        const whereSelectors = {
+            hash: {
+                eq: (val)=>{
+                    if ((0, $6B8p2$lodash).isNil(this._index)) {
+                        this._keys.push({
+                            key: this._hashKey,
+                            val: val,
+                            type: 'hash-eq'
+                        });
+                        return this;
+                    }
+                    (0, $6B8p2$assert)((0, $6B8p2$lodash).isString(this._index?.hashKey) && (0, $6B8p2$lodash).size(this._index.hashKey) > 0, 'Query.where.hash: Provided Index does not have a hashKey');
+                    this._keys.push({
+                        key: this._index.hashKey,
+                        val: val,
+                        type: 'hash-eq'
+                    });
+                    return this;
+                }
+            },
+            range: {
+                eq: (val)=>{
+                    pushRangeKey(val, 'eq');
+                    return this;
+                },
+                beginsWith: (val)=>{
+                    pushRangeKey(val, 'begins_with');
+                    return this;
+                },
+                gt: (val)=>{
+                    pushRangeKey(val, 'gt');
+                    return this;
+                },
+                gtEq: (val)=>{
+                    pushRangeKey(val, 'gtEq');
+                    return this;
+                },
+                lt: (val)=>{
+                    pushRangeKey(val, 'lt');
+                    return this;
+                },
+                ltEq: (val)=>{
+                    pushRangeKey(val, 'ltEq');
+                    return this;
+                },
+                between: (start, end)=>{
+                    pushRangeKey({
+                        start: start,
+                        end: end
+                    }, 'between');
+                    return this;
+                }
+            }
+        };
+        return whereSelectors;
+    }
+    get filter() {
+        const filterConditions = {
+            eq: (key, val)=>{
+                this._filters.push({
+                    key: key,
+                    val: val,
+                    type: 'eq'
+                });
+                return this;
+            },
+            notEq: (key, val)=>{
+                this._filters.push({
+                    key: key,
+                    val: val,
+                    type: 'notEq'
+                });
+                return this;
+            },
+            gt: (key, val)=>{
+                this._filters.push({
+                    key: key,
+                    val: val,
+                    type: 'gt'
+                });
+                return this;
+            },
+            gtEq: (key, val)=>{
+                this._filters.push({
+                    key: key,
+                    val: val,
+                    type: 'gtEq'
+                });
+                return this;
+            },
+            lt: (key, val)=>{
+                this._filters.push({
+                    key: key,
+                    val: val,
+                    type: 'lt'
+                });
+                return this;
+            },
+            ltEq: (key, val)=>{
+                this._filters.push({
+                    key: key,
+                    val: val,
+                    type: 'ltEq'
+                });
+                return this;
+            },
+            beginsWith: (key, val)=>{
+                this._filters.push({
+                    key: key,
+                    val: val,
+                    type: 'begins_with'
+                });
+                return this;
+            },
+            attributeExists: (key)=>{
+                this._filters.push({
+                    key: key,
+                    type: 'attribute_exists'
+                });
+                return this;
+            },
+            attributeNotExists: (key)=>{
+                this._filters.push({
+                    key: key,
+                    type: 'attribute_not_exists'
+                });
+                return this;
+            },
+            attributeType: (key, val)=>{
+                this._filters.push({
+                    key: key,
+                    val: val,
+                    type: 'attribute_type'
+                });
+                return this;
+            },
+            contains: (key, val)=>{
+                this._filters.push({
+                    key: key,
+                    val: val,
+                    type: 'contains'
+                });
+                return this;
+            },
+            size: (key, op, val)=>{
+                this._filters.push({
+                    key: key,
+                    val: {
+                        val: val,
+                        op: op
+                    },
+                    type: 'size'
+                });
+                return this;
+            },
+            between: (key, start, end)=>{
+                this._filters.push({
+                    key: key,
+                    val: {
+                        start: start,
+                        end: end
+                    },
+                    type: 'between'
+                });
+                return this;
+            },
+            raw: (filterCondition, replacements)=>{
+                this._rawFilters.push({
+                    condition: filterCondition,
+                    replacements: replacements
+                });
+                return this;
+            }
+        };
+        return filterConditions;
+    }
+    using(index, scanForward) {
+        (0, $6B8p2$assert)(typeof scanForward === 'boolean' || (0, $6B8p2$lodash).isNil(scanForward), 'Query.using(): scanForward must be a boolean or undefined');
+        this._index = index;
+        this._scanForward = scanForward;
+        return this;
+    }
+    limit(l) {
+        this._limit = l ?? $1ced42141bbfde9c$export$62297b13309008b2.DEFAULT_LIMIT;
+        return this;
+    }
+    startAfter(lastEvaluatedKey) {
+        this._startAfter = lastEvaluatedKey;
+        return this;
+    }
+    withConsumedCapacity(capacityType = 'TOTAL') {
+        (0, $6B8p2$assert)(capacityType === 'INDEXES' || capacityType === 'TOTAL' || capacityType === 'NONE', 'Query.withConsumedCapacity(): capacity type must be INDEXES, TOTAL, or NONE');
+        if (capacityType === 'NONE') return this;
+        this._consumedCapacity = capacityType;
+        return this;
+    }
+    toDynamo() {
+        const [keyCond, keyAttribVals, keyAttribNames] = $1ced42141bbfde9c$var$formatKeyCondition(this._keys);
+        const [filterCond, filterAttribVals, filterAttribNames] = $1ced42141bbfde9c$var$formatFilterCondition(this._filters, this._rawFilters);
+        const [projection, projectionAttribNames] = $1ced42141bbfde9c$var$formatProjectionExpression(this._selections);
+        return (0, $6B8p2$lodash).omitBy({
+            TableName: this._tableName,
+            Select: this._count ? 'COUNT' : undefined,
+            ...projection,
+            ...keyCond,
+            ...filterCond,
+            ...(0, $6B8p2$lodash).merge(keyAttribNames, filterAttribNames, projectionAttribNames),
+            ...(0, $6B8p2$lodash).merge(keyAttribVals, filterAttribVals),
+            Limit: this._limit,
+            IndexName: this._index?.name,
+            ScanIndexForward: this._scanForward,
+            ExclusiveStartKey: this._startAfter,
+            ReturnConsumedCapacity: this._consumedCapacity
+        }, (0, $6B8p2$lodash).isNil);
+    }
+}
+const $1ced42141bbfde9c$var$isReserved = (name)=>{
+    // Does the upper cased "name" exists in the reserved words list.
+    return (0, $6B8p2$lodash).indexOf((0, $8377f7c5fcf1cce8$export$e46d647da3214494), (0, $6B8p2$lodash).toUpper(name)) != -1;
+};
+const $1ced42141bbfde9c$var$replaceReservedNames = (conditions)=>{
+    return (0, $6B8p2$lodash).map(conditions, (cond)=>{
+        if ($1ced42141bbfde9c$var$isReserved(cond.key)) return {
+            ...cond,
+            key: `#${cond.key}`,
+            actualName: cond.key
+        };
+        if ((0, $6B8p2$lodash).startsWith(cond.key, "_")) return {
+            ...cond,
+            key: `#${cond.key}`,
+            actualName: cond.key
+        };
+        return cond;
+    });
+};
+const $1ced42141bbfde9c$var$formatKeyCondition = (conditions)=>{
+    const updatedConditions = $1ced42141bbfde9c$var$replaceReservedNames(conditions);
+    const conditionParts = [];
+    const attribVals = {};
+    const attribNames = {};
+    (0, $6B8p2$lodash).each(updatedConditions, (cond)=>{
+        const { key: key, val: val, type: type, actualName: actualName } = cond;
+        const valRef = `:${(0, $6B8p2$lodash).trim(key, '#')}`;
+        switch(type){
+            case "hash-eq":
+            case "eq":
+                conditionParts.push(`${key} = ${valRef}`);
+                (0, $6B8p2$lodash).set(attribVals, valRef, val);
+                break;
+            case "gt":
+                conditionParts.push(`${key} > ${valRef}`);
+                (0, $6B8p2$lodash).set(attribVals, valRef, val);
+                break;
+            case "gtEq":
+                conditionParts.push(`${key} >= ${valRef}`);
+                (0, $6B8p2$lodash).set(attribVals, valRef, val);
+                break;
+            case "lt":
+                conditionParts.push(`${key} < ${valRef}`);
+                (0, $6B8p2$lodash).set(attribVals, valRef, val);
+                break;
+            case "ltEq":
+                conditionParts.push(`${key} <= ${valRef}`);
+                (0, $6B8p2$lodash).set(attribVals, valRef, val);
+                break;
+            case "between":
+                {
+                    const valRefStart = `${valRef}_start`;
+                    const valRefEnd = `${valRef}_end`;
+                    const between = val;
+                    conditionParts.push(`${key} BETWEEN ${valRefStart} AND ${valRefEnd}`);
+                    (0, $6B8p2$lodash).set(attribVals, valRefStart, between.start);
+                    (0, $6B8p2$lodash).set(attribVals, valRefEnd, between.end);
+                    break;
+                }
+            case "begins_with":
+                conditionParts.push(`begins_with(${key}, ${valRef})`);
+                (0, $6B8p2$lodash).set(attribVals, valRef, val);
+                break;
+        }
+        if (actualName) (0, $6B8p2$lodash).set(attribNames, key, actualName);
+    });
+    return [
+        {
+            KeyConditionExpression: (0, $6B8p2$lodash).isEmpty(conditionParts) ? undefined : (0, $6B8p2$lodash).join(conditionParts, " and ")
+        },
+        {
+            ExpressionAttributeValues: (0, $6B8p2$lodash).isEmpty(attribVals) ? undefined : attribVals
+        },
+        {
+            ExpressionAttributeNames: (0, $6B8p2$lodash).isEmpty(attribNames) ? undefined : attribNames
+        }
+    ];
+};
+const $1ced42141bbfde9c$var$formatFilterCondition = (filters, rawFilters)=>{
+    const updatedFilters = $1ced42141bbfde9c$var$replaceReservedNames(filters);
+    const filterParts = [];
+    const attribVals = {};
+    const attribNames = {};
+    const usedValRefs = new Set();
+    (0, $6B8p2$lodash).each(updatedFilters, (f)=>{
+        let valRef = `:${(0, $6B8p2$lodash).trim(f.key, '#')}`;
+        // Add numeric suffix if valRef is already used
+        if (usedValRefs.has(valRef)) {
+            let counter = 1;
+            while(usedValRefs.has(`${valRef}_${counter}`))counter++;
+            valRef = `${valRef}_${counter}`;
+        }
+        usedValRefs.add(valRef);
+        switch(f.type){
+            case 'eq':
+                (0, $6B8p2$lodash).set(attribVals, valRef, f.val);
+                filterParts.push(`${f.key} = ${valRef}`);
+                break;
+            case 'notEq':
+                (0, $6B8p2$lodash).set(attribVals, valRef, f.val);
+                filterParts.push(`${f.key} <> ${valRef}`);
+                break;
+            case 'gt':
+                (0, $6B8p2$lodash).set(attribVals, valRef, f.val);
+                filterParts.push(`${f.key} > ${valRef}`);
+                break;
+            case 'gtEq':
+                (0, $6B8p2$lodash).set(attribVals, valRef, f.val);
+                filterParts.push(`${f.key} >= ${valRef}`);
+                break;
+            case 'lt':
+                (0, $6B8p2$lodash).set(attribVals, valRef, f.val);
+                filterParts.push(`${f.key} < ${valRef}`);
+                break;
+            case 'ltEq':
+                (0, $6B8p2$lodash).set(attribVals, valRef, f.val);
+                filterParts.push(`${f.key} <= ${valRef}`);
+                break;
+            case 'begins_with':
+                (0, $6B8p2$lodash).set(attribVals, valRef, f.val);
+                filterParts.push(`begins_with(${f.key}, ${valRef})`);
+                break;
+            case 'attribute_exists':
+                (0, $6B8p2$lodash).set(attribVals, valRef, f.val);
+                filterParts.push(`attribute_exists(${f.key})`);
+                break;
+            case 'attribute_not_exists':
+                (0, $6B8p2$lodash).set(attribVals, valRef, f.val);
+                filterParts.push(`attribute_not_exists(${f.key})`);
+                break;
+            case 'attribute_type':
+                (0, $6B8p2$lodash).set(attribVals, valRef, f.val);
+                filterParts.push(`attribute_type(${f.key}, ${valRef})`);
+                break;
+            case 'contains':
+                (0, $6B8p2$lodash).set(attribVals, valRef, f.val);
+                filterParts.push(`contains(${f.key}, ${valRef})`);
+                break;
+            case 'size':
+                {
+                    const sizeVal = f.val;
+                    const newValRef = `:size_${(0, $6B8p2$lodash).trim(valRef, ':')}`;
+                    (0, $6B8p2$lodash).set(attribVals, newValRef, sizeVal.val);
+                    filterParts.push(`size(${f.key}) ${sizeVal.op} ${newValRef}`);
+                    break;
+                }
+            case 'between':
+                {
+                    const valRefStart = `${valRef}_start`;
+                    const valRefEnd = `${valRef}_end`;
+                    const between = f.val;
+                    filterParts.push(`${f.key} BETWEEN ${valRefStart} AND ${valRefEnd}`);
+                    (0, $6B8p2$lodash).set(attribVals, valRefStart, between.start);
+                    (0, $6B8p2$lodash).set(attribVals, valRefEnd, between.end);
+                    break;
+                }
+        }
+        if (f.actualName) (0, $6B8p2$lodash).set(attribNames, f.key, f.actualName);
+    });
+    let filterExp = (0, $6B8p2$lodash).join(filterParts, ' and ');
+    if (rawFilters.length > 0) {
+        const rawFilterCondition = (0, $6B8p2$lodash).chain(rawFilters).map((f)=>f ? `(${f.condition})` : undefined).compact().join(' and ').value();
+        if ((0, $6B8p2$lodash).isEmpty(filterExp)) filterExp = rawFilterCondition;
+        else filterExp = (0, $6B8p2$lodash).join([
+            filterExp,
+            rawFilterCondition
+        ], ' and ');
+        (0, $6B8p2$lodash).merge(attribVals, (0, $6B8p2$lodash).chain(rawFilters).map((f)=>f?.replacements.vals).compact().reduce((0, $6B8p2$lodash).merge, {}).value());
+        (0, $6B8p2$lodash).merge(attribNames, (0, $6B8p2$lodash).chain(rawFilters).map((f)=>f?.replacements.keys).compact().reduce((0, $6B8p2$lodash).merge, {}).value());
+    }
+    return [
+        {
+            FilterExpression: (0, $6B8p2$lodash).isEmpty(filterExp) ? undefined : filterExp
+        },
+        {
+            ExpressionAttributeValues: (0, $6B8p2$lodash).isEmpty(attribVals) ? undefined : attribVals
+        },
+        {
+            ExpressionAttributeNames: (0, $6B8p2$lodash).isEmpty(attribNames) ? undefined : attribNames
+        }
+    ];
+};
+const $1ced42141bbfde9c$var$formatProjectionExpression = (proj)=>{
+    const attribNames = {};
+    const projection = (0, $6B8p2$lodash).map(proj, (col)=>{
+        const attribRef = `#${(0, $6B8p2$lodash).trim(col)}`;
+        if ($1ced42141bbfde9c$var$isReserved(col)) {
+            (0, $6B8p2$lodash).set(attribNames, attribRef, col);
+            return attribRef;
+        }
+        if ((0, $6B8p2$lodash).startsWith(col, "_")) {
+            (0, $6B8p2$lodash).set(attribNames, attribRef, col);
+            return attribRef;
+        }
+        return col;
+    });
+    return [
+        {
+            ProjectionExpression: (0, $6B8p2$lodash).isEmpty(projection) ? undefined : (0, $6B8p2$lodash).join(projection, ", ")
+        },
+        {
+            ExpressionAttributeNames: (0, $6B8p2$lodash).isEmpty(attribNames) ? undefined : attribNames
+        }
+    ];
+};
+function $1ced42141bbfde9c$var$throwIfModeExists(mode) {
+    (0, $6B8p2$assert)((0, $6B8p2$lodash).isEmpty(mode), 'Query: Cannot use more than one mode (select, count, scan) at the same time.');
+}
+
+
+
+
+class $bfdbbc60df8720b8$export$54ec01a60f47d33d {
+    constructor(name, hashKey, rangeKey){
+        (0, $6B8p2$assert)((0, $6B8p2$lodash).isString(name) && (0, $6B8p2$lodash).size(name) > 0, 'Table.constructor(): name must be provided');
+        (0, $6B8p2$assert)((0, $6B8p2$lodash).isString(hashKey) && (0, $6B8p2$lodash).size(hashKey) > 0, 'Table.constructor(): hashKey must be provided');
+        (0, $6B8p2$assert)((0, $6B8p2$lodash).isNil(rangeKey) || (0, $6B8p2$lodash).isString(rangeKey) && (0, $6B8p2$lodash).size(rangeKey) > 0, 'Table.constructor(): rangeKey is invalid');
+        this._name = name;
+        this._hashKey = hashKey;
+        this._rangeKey = rangeKey;
+    }
+    get name() {
+        return this._name;
+    }
+    get hashKey() {
+        return this._hashKey;
+    }
+    get rangeKey() {
+        return this._rangeKey;
+    }
+}
+class $bfdbbc60df8720b8$export$cf17b003b6192af3 {
+    constructor(name, hashKey, rangeKey){
+        (0, $6B8p2$assert)((0, $6B8p2$lodash).isString(name) && (0, $6B8p2$lodash).size(name) > 0, 'Index.constructor(): name must be provided');
+        (0, $6B8p2$assert)((0, $6B8p2$lodash).isString(hashKey) && (0, $6B8p2$lodash).size(hashKey) > 0, 'Index.constructor(): hashKey must be provided');
+        this._name = name;
+        this._hashKey = hashKey;
+        this._rangeKey = rangeKey;
+    }
+    get name() {
+        return this._name;
+    }
+    get hashKey() {
+        return this._hashKey;
+    }
+    get rangeKey() {
+        return this._rangeKey;
+    }
+}
+
+
+
+
+export {$1ced42141bbfde9c$export$62297b13309008b2 as Query, $1ced42141bbfde9c$export$99a24bd46fd1f406 as DdbType, $1ced42141bbfde9c$export$ab5aad00225c5662 as Operation, $bfdbbc60df8720b8$export$cf17b003b6192af3 as Index, $bfdbbc60df8720b8$export$54ec01a60f47d33d as Table};
+//# sourceMappingURL=module.js.map