@qrvey/data-persistence 0.5.8 → 0.5.9-bundled

package/dist/esm/dynamoDbCrud.service-NRSGRPDQ.mjs

@@ -1,796 +0,0 @@
-import { getTableName, findIdColumnName, getPrimaryKeyColumns, PersistenceErrorWrapper } from './chunk-2H6RO6ZL.mjs';
-import { __privateAdd, __spreadProps, __spreadValues, FILTER_OPERATOR_MAP, DYNAMODB_OPERATORS, __privateMethod, DYNAMO_DB_UPDATE_ACTIONS } from './chunk-2OYWEFNZ.mjs';
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import { DynamoDBDocumentClient, GetCommand, QueryCommand, ScanCommand, PutCommand, UpdateCommand, DeleteCommand, BatchWriteCommand } from '@aws-sdk/lib-dynamodb';
-
-var AWS_REGION = process.env.AWS_DEFAULT_REGION;
-var DynamoDbClientService = class {
-  constructor(tableName) {
-    if (!tableName)
-      throw new Error(
-        'The "tableName" is required to use a DynamoDbClientService.'
-      );
-    this.tableName = tableName;
-    const client = new DynamoDBClient({ region: AWS_REGION });
-    this.dynamoDBClient = DynamoDBDocumentClient.from(client, {
-      marshallOptions: {
-        removeUndefinedValues: true
-      }
-    });
-  }
-  /**
-   * Get an item by key
-   * @param {Object} keyObject - Ex: { jobId: 1234 }
-   * @param {GetCommandInput} options
-   */
-  async getByKey(keyObject, options = {}) {
-    const params = __spreadValues({
-      TableName: this.tableName,
-      Key: keyObject
-    }, options);
-    const result = await this.dynamoDBClient.send(new GetCommand(params));
-    return result.Item;
-  }
-  /**
-   * Query a table
-   * @param {QueryCommandInput} options
-   */
-  async query(options = {}) {
-    const params = __spreadValues({
-      TableName: this.tableName
-    }, options);
-    const result = await this.dynamoDBClient.send(new QueryCommand(params));
-    if (result.$metadata) delete result.$metadata;
-    return result;
-  }
-  /**
-   * Scan a table
-   * @param {ScanInput} options
-   */
-  async scan(input) {
-    const params = __spreadProps(__spreadValues({}, input), {
-      TableName: this.tableName
-    });
-    const command = new ScanCommand(params);
-    const response = await this.dynamoDBClient.send(command);
-    if (response.$metadata) delete response.$metadata;
-    return response;
-  }
-  /**
-   * Create/Replace a item object
-   * To take care:
-   * - https://stackoverflow.com/questions/43667229/difference-between-dynamodb-putitem-vs-updateitem
-   * @param {Object} input
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async put(input) {
-    const params = {
-      TableName: this.tableName,
-      Item: input,
-      ReturnValues: "NONE"
-    };
-    return await this.dynamoDBClient.send(new PutCommand(params));
-  }
-  /**
-   * Update a item object
-   * To take care:
-   * - https://stackoverflow.com/questions/43667229/difference-between-dynamodb-putitem-vs-updateitem
-   * @param {Object} keyObject - Ex: { jobId: 1234 }
-   * @param {UpdateCommandInput} updateObject
-   */
-  async update(keyObject, options = {}) {
-    const params = __spreadValues({
-      TableName: this.tableName,
-      Key: keyObject,
-      ReturnValues: "NONE"
-    }, options);
-    return await this.dynamoDBClient.send(new UpdateCommand(params));
-  }
-  /**
-   * Delete/Remove an item object
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async remove(keyObject) {
-    const params = {
-      TableName: this.tableName,
-      Key: keyObject,
-      ReturnValues: "NONE"
-    };
-    return await this.dynamoDBClient.send(new DeleteCommand(params));
-  }
-  batchWrittenPut(data) {
-    const putRequests = data.map((item) => ({
-      PutRequest: {
-        Item: item
-      }
-    }));
-    const params = {
-      RequestItems: {
-        [this.tableName]: putRequests
-      }
-    };
-    const insertCommand = new BatchWriteCommand(params);
-    return this.dynamoDBClient.send(insertCommand);
-  }
-  buildDeleteRequestKeys(filters) {
-    const deleteRequestKeys = {};
-    filters.forEach((filter) => {
-      deleteRequestKeys[filter.attribute] = filter.value;
-    });
-    return deleteRequestKeys;
-  }
-  async batchRemove(filterGroups) {
-    if (!(filterGroups == null ? void 0 : filterGroups.length)) return;
-    const deleteRequests = filterGroups.map((filterGroup) => ({
-      DeleteRequest: {
-        Key: this.buildDeleteRequestKeys(filterGroup)
-      }
-    }));
-    const params = {
-      RequestItems: {
-        [this.tableName]: deleteRequests
-      }
-    };
-    await this.dynamoDBClient.send(new BatchWriteCommand(params));
-  }
-  async updateExpressions(keyObject, options = {}) {
-    const params = __spreadValues({
-      TableName: this.tableName,
-      Key: keyObject
-    }, options);
-    return await this.dynamoDBClient.send(new UpdateCommand(params));
-  }
-};
-
-// src/services/cruds/dynamodb/queryBuilderCondition.service.ts
-var QueryBuilderConditionService = class {
-  constructor(query) {
-    this.tempKey = "";
-    this.tempLogicOperator = null;
-    this.wheres = [];
-    this.filters = [];
-    this.updates = [];
-    this.attributeNames = {};
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    this.attributeValues = {};
-    this.query = query;
-    this.command = {};
-  }
-  get() {
-    this.build();
-    return this.command;
-  }
-  setKey(key) {
-    this.tempKey = key;
-    return this;
-  }
-  setTmpLogicOp(logicOp) {
-    this.tempLogicOperator = logicOp;
-    return this;
-  }
-  setConfig(config) {
-    this.config = config;
-    return this;
-  }
-  from(methodName) {
-    this.queryFrom = methodName;
-    return this;
-  }
-  eq(keyValue) {
-    const { key, value } = this.generateKeyValue(keyValue);
-    let expression = `${key} = ${value}`;
-    if (this.tempLogicOperator)
-      expression = { expression, logicOperator: this.tempLogicOperator, config: this.config };
-    this.setExpression(expression);
-    return this.query;
-  }
-  notEq(keyValue) {
-    const { key, value } = this.generateKeyValue(keyValue);
-    let expression = `${key} <> ${value}`;
-    if (this.tempLogicOperator)
-      expression = { expression, logicOperator: this.tempLogicOperator, config: this.config };
-    this.setExpression(expression);
-    return this.query;
-  }
-  contains(keyValue) {
-    const { key, value } = this.generateKeyValue(keyValue);
-    let expression = `contains(${key}, ${value})`;
-    if (this.tempLogicOperator)
-      expression = { expression, logicOperator: this.tempLogicOperator, config: this.config };
-    this.setExpression(expression);
-    return this.query;
-  }
-  notContains(keyValue) {
-    const { key, value } = this.generateKeyValue(keyValue);
-    let expression = `NOT contains(${key}, ${value})`;
-    if (this.tempLogicOperator)
-      expression = { expression, logicOperator: this.tempLogicOperator, config: this.config };
-    this.setExpression(expression);
-    return this.query;
-  }
-  in(keyValue) {
-    const keyValues = Array.isArray(keyValue) ? keyValue : [keyValue];
-    const { key, value } = this.generateKeyValue(keyValues);
-    let expression = `${key} IN (${value})`;
-    if (this.tempLogicOperator)
-      expression = { expression, logicOperator: this.tempLogicOperator, config: this.config };
-    this.setExpression(expression);
-    return this.query;
-  }
-  beginsWith(keyValue) {
-    const { key, value } = this.generateKeyValue(keyValue);
-    let expression = `begins_with(${key}, ${value})`;
-    if (this.tempLogicOperator)
-      expression = { expression, logicOperator: this.tempLogicOperator, config: this.config };
-    this.setExpression(expression);
-    return this.query;
-  }
-  project(keyValue) {
-    const key = `#${keyValue}`;
-    this.attributeNames[key] = keyValue;
-    return key;
-  }
-  gt(keyValue) {
-    const { key, value } = this.generateKeyValue(keyValue);
-    let expression = `${key} > ${value}`;
-    if (this.tempLogicOperator)
-      expression = { expression, logicOperator: this.tempLogicOperator, config: this.config };
-    this.setExpression(expression);
-    return this.query;
-  }
-  gte(keyValue) {
-    const { key, value } = this.generateKeyValue(keyValue);
-    let expression = `${key} >= ${value}`;
-    if (this.tempLogicOperator)
-      expression = { expression, logicOperator: this.tempLogicOperator, config: this.config };
-    this.setExpression(expression);
-    return this.query;
-  }
-  lte(keyValue) {
-    const { key, value } = this.generateKeyValue(keyValue);
-    let expression = `${key} <= ${value}`;
-    if (this.tempLogicOperator)
-      expression = { expression, logicOperator: this.tempLogicOperator, config: this.config };
-    this.setExpression(expression);
-    return this.query;
-  }
-  lt(keyValue) {
-    const { key, value } = this.generateKeyValue(keyValue);
-    let expression = `${key} < ${value}`;
-    if (this.tempLogicOperator)
-      expression = { expression, logicOperator: this.tempLogicOperator, config: this.config };
-    this.setExpression(expression);
-    return this.query;
-  }
-  attribute_exists(keyValue) {
-    const { key } = this.generateKeyValue(keyValue, null, true);
-    let expression = `attribute_exists(${key})`;
-    if (this.tempLogicOperator)
-      expression = { expression, logicOperator: this.tempLogicOperator, config: this.config };
-    this.setExpression(expression);
-    return this.query;
-  }
-  attribute_not_exists(keyValue) {
-    const { key } = this.generateKeyValue(keyValue, null, true);
-    let expression = `attribute_not_exists(${key})`;
-    if (this.tempLogicOperator)
-      expression = { expression, logicOperator: this.tempLogicOperator, config: this.config };
-    this.setExpression(expression);
-    return this.query;
-  }
-  between(keyValues) {
-    const isValidValues = Array.isArray(keyValues) && (keyValues == null ? void 0 : keyValues.length) === 2;
-    if (!isValidValues)
-      throw new Error(
-        "The value for between filter operator should be an Array with 2 values."
-      );
-    const { key, value } = this.generateKeyValue(keyValues, " AND");
-    let expression = `${key} between ${value}`;
-    if (this.tempLogicOperator)
-      expression = { expression, logicOperator: this.tempLogicOperator, config: this.config };
-    this.setExpression(expression);
-    return this.query;
-  }
-  setExpression(expression) {
-    switch (this.queryFrom) {
-      case "filter" /* filter */:
-        this.filters.push(expression);
-        break;
-      case "update" /* update */:
-        this.updates.push(expression);
-        break;
-      default:
-        this.wheres.push(expression);
-        break;
-    }
-  }
-  generateKeyValue(value, separatorCharacter = ",", omitAttributeValues = false) {
-    const keyExpression = `#${this.tempKey}1`;
-    this.attributeNames[keyExpression] = this.tempKey;
-    if (Array.isArray(value)) {
-      const valueExpressions = value.map((val, index) => {
-        let valueExpression = `:${this.tempKey}${index + 1}1`;
-        for (const [i] of Object.entries(this.attributeValues)) {
-          if (i === valueExpression) valueExpression += "1";
-        }
-        this.attributeValues[valueExpression] = val;
-        return valueExpression;
-      });
-      return {
-        key: keyExpression,
-        value: valueExpressions.join(`${separatorCharacter} `)
-      };
-    } else {
-      let valueExpression = `:${this.tempKey}1`;
-      if (valueExpression in this.attributeValues) {
-        for (const [index] of Object.entries(this.attributeValues)) {
-          if (index === valueExpression) valueExpression += "1";
-        }
-      }
-      if (!omitAttributeValues)
-        this.attributeValues[valueExpression] = value;
-      return { key: keyExpression, value: valueExpression };
-    }
-  }
-  build() {
-    var _a;
-    if (this.wheres.length > 0) {
-      const keyConditionExpression = this.wheres.join(" AND ");
-      this.command["KeyConditionExpression"] = keyConditionExpression;
-    }
-    if (this.filters.length > 0) {
-      let filterExpression = "";
-      (_a = this.filters) == null ? void 0 : _a.forEach((filter, index) => {
-        var _a2, _b;
-        if (filter == null ? void 0 : filter.logicOperator) {
-          if ((_a2 = filter == null ? void 0 : filter.config) == null ? void 0 : _a2.openExpression) {
-            filterExpression = filterExpression.replace(/\s+(AND|OR)\s*$/, ` ${filter.config.parentKey} (`);
-            if (filterExpression === "") filterExpression += "(";
-            filterExpression += `${filter.expression} ${filter.logicOperator} `;
-          } else if ((_b = filter == null ? void 0 : filter.config) == null ? void 0 : _b.closeExpression) {
-            filterExpression += `${filter.expression}) ${filter.config.parentKey} `;
-          } else {
-            filterExpression += `${filter.expression} ${filter.logicOperator} `;
-          }
-        }
-      });
-      filterExpression = filterExpression.replace(/\s+(AND|OR)\s*$/, "");
-      this.command["FilterExpression"] = filterExpression;
-    }
-    if (this.updates.length > 0) {
-      const filterExpression = this.updates.join(", ");
-      this.command["UpdateExpression"] = `SET ${filterExpression}`;
-    }
-    if (Object.values(this.attributeNames).length > 0)
-      this.command["ExpressionAttributeNames"] = this.attributeNames;
-    if (Object.values(this.attributeValues).length > 0)
-      this.command["ExpressionAttributeValues"] = this.attributeValues;
-  }
-};
-
-// src/services/cruds/dynamodb/queryBuilder.service.ts
-var QueryBuilderService = class {
-  constructor(useScan = false) {
-    this.useScan = useScan;
-    this.command = {};
-    this.condition = new QueryBuilderConditionService(this);
-  }
-  get() {
-    const condition = this.condition.get();
-    return __spreadValues(__spreadValues({}, this.command), condition);
-  }
-  limit(num) {
-    this.command.Limit = num;
-    return this;
-  }
-  usingIndex(indexName) {
-    this.command.IndexName = indexName;
-    return this;
-  }
-  ascending() {
-    if (!this.useScan) this.command.ScanIndexForward = true;
-    return this;
-  }
-  descending() {
-    if (!this.useScan) this.command.ScanIndexForward = false;
-    return this;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  startKey(lastEvaluatedKey) {
-    this.command.ExclusiveStartKey = lastEvaluatedKey;
-    return this;
-  }
-  projection(fields = []) {
-    if (!fields.length) return this;
-    const expression = [];
-    fields.forEach((field) => {
-      const key = this.condition.project(field);
-      expression.push(key);
-    });
-    this.command.ProjectionExpression = expression.join(",");
-    return this;
-  }
-  where(keyName) {
-    this.condition.setKey(keyName).setTmpLogicOp(null).from("where" /* where */);
-    return this.condition;
-  }
-  filter(keyName, logicOperator = "AND", config) {
-    this.condition.setKey(keyName).setTmpLogicOp(logicOperator).setConfig(config).from("filter" /* filter */);
-    return this.condition;
-  }
-  update(attribute) {
-    for (const [key, value] of Object.entries(attribute)) {
-      this.condition.setKey(key).from("update" /* update */);
-      this.condition.eq(value);
-    }
-    return this;
-  }
-  consistentRead(consistentRead) {
-    this.command.ConsistentRead = consistentRead;
-    return this;
-  }
-  count() {
-    this.command.Select = "COUNT" /* COUNT */;
-    return this;
-  }
-};
-
-// src/services/cruds/dynamodb/dynamoDbCrud.service.ts
-var _DynamoDbCrudService_instances, prepareAndExecuteUpdateExpression_fn, buildUpdateExpressionQuery_fn, getKeyObjectForUpdateExpression_fn, getUpdateExpressionOptions_fn, extractUpdateExpressionAttributesAndNames_fn;
-var DynamoDbCrudService = class {
-  constructor(tableSchema) {
-    this.tableSchema = tableSchema;
-    __privateAdd(this, _DynamoDbCrudService_instances);
-    this.dynamoDbClientService = new DynamoDbClientService(this.tableName);
-  }
-  get tableName() {
-    return getTableName(this.tableSchema.table);
-  }
-  get idColumnName() {
-    return findIdColumnName(this.tableSchema.columns);
-  }
-  get defaultPrimaryKeys() {
-    return getPrimaryKeyColumns(this.tableSchema.columns);
-  }
-  async create(data) {
-    var _a;
-    if (Array.isArray(data)) {
-      const response = await this.dynamoDbClientService.batchWrittenPut(data);
-      return {
-        unprocessedItems: (_a = response.UnprocessedItems) != null ? _a : []
-      };
-    } else {
-      await this.dynamoDbClientService.put(data);
-      return data;
-    }
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
-  runQuery(queryCommand) {
-    throw new Error("Method not implemented.");
-  }
-  find(options = {}) {
-    var _a, _b, _c, _d;
-    const query = new QueryBuilderService(options.useScan);
-    if ((_a = options.index) == null ? void 0 : _a.indexName)
-      query.usingIndex((_b = options.index) == null ? void 0 : _b.indexName);
-    this.applySorting(query, options.sorting, (_c = options.index) == null ? void 0 : _c.indexName);
-    this.applyPagination(query, options.pagination);
-    if (options.consistentRead)
-      query.consistentRead(options.consistentRead);
-    if (options.fields) query.projection(options.fields);
-    this.applyFilters(query, options);
-    if (options.aggregateFunction === "COUNT" /* COUNT */)
-      query.count();
-    return this.fetchResults(
-      query.get(),
-      (_d = options.pagination) == null ? void 0 : _d.limit,
-      options.useScan
-    ).then((res) => {
-      var _a2, _b2;
-      const pagination = {};
-      if (res.lastEvaluatedKey) pagination.from = res.lastEvaluatedKey;
-      if ((_a2 = options.pagination) == null ? void 0 : _a2.limit)
-        pagination.limit = (_b2 = options.pagination) == null ? void 0 : _b2.limit;
-      return {
-        items: res.items,
-        pagination,
-        count: res.count
-      };
-    });
-  }
-  async fetchResults(command, limit = 100, useScan = false) {
-    var _a, _b;
-    let results = [];
-    let lastEvaluatedKey = {};
-    let rowsCount = 0;
-    do {
-      const result = await this.fetchBatch(
-        command,
-        useScan,
-        lastEvaluatedKey
-      );
-      const rows = (_a = result.Items) != null ? _a : [];
-      results = results.concat(rows);
-      lastEvaluatedKey = (_b = result.LastEvaluatedKey) != null ? _b : {};
-      rowsCount += result.Count || rows.length;
-    } while (rowsCount < limit && this.isNotEmptyObject(lastEvaluatedKey));
-    const encryptedLastEvaluatedKey = this.isNotEmptyObject(
-      lastEvaluatedKey
-    ) ? this.encryptPaginationKey(lastEvaluatedKey) : null;
-    return {
-      items: results,
-      lastEvaluatedKey: encryptedLastEvaluatedKey,
-      count: rowsCount
-    };
-  }
-  async fetchBatch(command, useScan, lastEvaluatedKey) {
-    var _a, _b, _c;
-    if (this.isNotEmptyObject(lastEvaluatedKey))
-      command.ExclusiveStartKey = lastEvaluatedKey;
-    const result = await (useScan ? this.dynamoDbClientService.scan(command) : this.dynamoDbClientService.query(command));
-    if (command.Select !== "COUNT" /* COUNT */) {
-      command.Limit = ((_a = command.Limit) != null ? _a : 0) - ((_c = (_b = result.Items) == null ? void 0 : _b.length) != null ? _c : 0);
-    }
-    return result;
-  }
-  applyPagination(query, pagination) {
-    if (pagination == null ? void 0 : pagination.limit) query.limit(pagination.limit);
-    if (pagination == null ? void 0 : pagination.from)
-      query.startKey(this.decryptPaginationKey(pagination.from));
-  }
-  async findAll(options = {}, allResults = [], rowsCount = 0) {
-    const { items, pagination, count } = await this.find(options);
-    allResults.push(...items);
-    rowsCount += count;
-    if (pagination == null ? void 0 : pagination.from)
-      await this.findAll(__spreadProps(__spreadValues({}, options), { pagination }), allResults);
-    return {
-      items: allResults,
-      pagination: null,
-      count: rowsCount
-    };
-  }
-  async findCount(options = {}) {
-    var _a;
-    const findOptions = __spreadProps(__spreadValues({}, options), {
-      aggregateFunction: "COUNT" /* COUNT */
-    });
-    if ((_a = options.pagination) == null ? void 0 : _a.from) {
-      return this.find(findOptions).then((res) => res.count);
-    } else {
-      return this.findAll(findOptions).then((res) => res.count);
-    }
-  }
-  buildFindItemQuery(options) {
-    var _a;
-    const query = new QueryBuilderService();
-    if ((_a = options.index) == null ? void 0 : _a.indexName) query.usingIndex(options.index.indexName);
-    this.applyFilters(query, options);
-    query.projection(options.fields);
-    query.limit(1);
-    return query;
-  }
-  findItem(options) {
-    const query = this.buildFindItemQuery(options);
-    return this.dynamoDbClientService.query(query.get()).then((result) => {
-      var _a;
-      if ((_a = result.Items) == null ? void 0 : _a.length) return result.Items[0];
-      if (options.throwErrorIfNull) throw new Error("NOT_FOUND");
-      return null;
-    });
-  }
-  applyWhereFilter(query, filter) {
-    var _a, _b;
-    const operator = FILTER_OPERATOR_MAP[(_b = (_a = filter.operator) == null ? void 0 : _a.toUpperCase()) != null ? _b : DYNAMODB_OPERATORS.EQUAL];
-    query.where(filter.attribute)[operator](filter.value);
-  }
-  applyFilterFilter(query, filter, logicOperator = "AND", config) {
-    var _a, _b;
-    const operator = FILTER_OPERATOR_MAP[(_b = (_a = filter.operator) == null ? void 0 : _a.toUpperCase()) != null ? _b : DYNAMODB_OPERATORS.EQUAL];
-    query.filter(filter.attribute, logicOperator, config)[operator](filter.value);
-  }
-  applyFilters(query, options) {
-    if (Array.isArray(options.filters)) {
-      this.applySimpleFilters(query, options);
-    } else {
-      this.applyCompoundFilters(query, options);
-    }
-  }
-  applySimpleFilters(query, options) {
-    var _a, _b;
-    const queryIndexColumns = (_b = (_a = options.index) == null ? void 0 : _a.columns) != null ? _b : [];
-    const defaultWhereProperties = this.defaultPrimaryKeys;
-    const whereProperties = (queryIndexColumns == null ? void 0 : queryIndexColumns.length) ? queryIndexColumns : defaultWhereProperties;
-    const filters = options.filters;
-    filters.forEach((filter) => {
-      const isWhereProperty = whereProperties.includes(filter.attribute);
-      isWhereProperty && !options.useScan ? this.applyWhereFilter(query, filter) : this.applyFilterFilter(query, filter);
-    });
-  }
-  applyCompoundFilters(query, options) {
-    if (!options.filters) return;
-    this.buildFilterExpression(query, options);
-  }
-  buildFilterExpression(query, options, parentKey) {
-    var _a;
-    const compositeFilters = options.filters;
-    const queryIndexColumns = ((_a = options.index) == null ? void 0 : _a.columns) || [];
-    const defaultWhereProperties = this.defaultPrimaryKeys;
-    const whereProperties = (queryIndexColumns == null ? void 0 : queryIndexColumns.length) ? queryIndexColumns : defaultWhereProperties;
-    for (const [key, value] of Object.entries(compositeFilters)) {
-      value.forEach(
-        (filter, index) => {
-          const isCompositeFilter = "OR" in filter || "AND" in filter;
-          if (isCompositeFilter) {
-            const newOptions = __spreadProps(__spreadValues({}, options), {
-              filters: filter
-            });
-            this.buildFilterExpression(query, newOptions, key);
-          } else {
-            const simpleFilter = filter;
-            const isWhereProperty = whereProperties.includes(
-              simpleFilter.attribute
-            );
-            let config;
-            if (parentKey) {
-              config = {
-                parentKey,
-                openExpression: index === 0,
-                closeExpression: index === value.length - 1
-              };
-            }
-            isWhereProperty && !options.useScan ? this.applyWhereFilter(query, simpleFilter) : this.applyFilterFilter(
-              query,
-              simpleFilter,
-              key,
-              config
-            );
-          }
-        }
-      );
-    }
-  }
-  applySorting(query, sorting, sortIndex) {
-    if (sorting == null ? void 0 : sorting.length) {
-      if (sortIndex) query.usingIndex(sortIndex);
-      if (sorting[0].direction === "DESC") {
-        query.descending();
-      } else {
-        query.ascending();
-      }
-    }
-  }
-  isNotEmptyObject(obj) {
-    return obj !== null && typeof obj === "object" && Object.keys(obj).length > 0;
-  }
-  encryptPaginationKey(key) {
-    const jsonKey = JSON.stringify(key);
-    return Buffer.from(jsonKey).toString("base64");
-  }
-  decryptPaginationKey(encodedKey) {
-    const decodedKey = Buffer.from(encodedKey, "base64").toString("utf-8");
-    return JSON.parse(decodedKey);
-  }
-  async update(filters, data, { replace = false }) {
-    const savedRecord = await this.findItem({
-      filters
-    });
-    const newData = __spreadValues(__spreadValues({}, savedRecord), data);
-    await this.dynamoDbClientService.put(newData);
-    return newData;
-  }
-  async remove(filters, options) {
-    if (options == null ? void 0 : options.filterGroups) {
-      await this.dynamoDbClientService.batchRemove(
-        filters
-      );
-    } else {
-      const key = filters.reduce((obj, item) => {
-        const property = item.attribute;
-        obj[property] = item.value;
-        return obj;
-      }, {});
-      await this.dynamoDbClientService.remove(key);
-    }
-  }
-  async updateExpressions(filters, actions, options) {
-    try {
-      return await __privateMethod(this, _DynamoDbCrudService_instances, prepareAndExecuteUpdateExpression_fn).call(this, filters, actions, options);
-    } catch (error) {
-      PersistenceErrorWrapper(error);
-    }
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  runRawQuery(query, params) {
-    throw new Error("Method not implemented.");
-  }
-};
-_DynamoDbCrudService_instances = new WeakSet();
-prepareAndExecuteUpdateExpression_fn = async function(filters, actions, options) {
-  const queryObject = __privateMethod(this, _DynamoDbCrudService_instances, buildUpdateExpressionQuery_fn).call(this, { filters }).get();
-  const primaryKeys = this.defaultPrimaryKeys;
-  const keyObject = __privateMethod(this, _DynamoDbCrudService_instances, getKeyObjectForUpdateExpression_fn).call(this, queryObject, primaryKeys);
-  const updateExpressions = [];
-  Object.keys(actions).forEach((action) => {
-    const actionUpdateExpression = __privateMethod(this, _DynamoDbCrudService_instances, extractUpdateExpressionAttributesAndNames_fn).call(this, actions, action);
-    updateExpressions.push(actionUpdateExpression);
-  });
-  const dbParams = __spreadValues({
-    UpdateExpression: updateExpressions.join(" ")
-  }, __privateMethod(this, _DynamoDbCrudService_instances, getUpdateExpressionOptions_fn).call(this, options));
-  const { ExpressionAttributeValues, ExpressionAttributeNames } = queryObject;
-  if (Object.keys(ExpressionAttributeValues).length > 0) {
-    dbParams["ExpressionAttributeValues"] = __spreadValues(__spreadValues({}, ExpressionAttributeValues), dbParams.ExpressionAttributeValues);
-  }
-  if (Object.keys(ExpressionAttributeNames).length > 0) {
-    dbParams["ExpressionAttributeNames"] = __spreadValues(__spreadValues({}, ExpressionAttributeNames), dbParams.ExpressionAttributeNames);
-  }
-  if (queryObject.FilterExpression)
-    dbParams["ConditionExpression"] = queryObject.FilterExpression;
-  return this.dynamoDbClientService.updateExpressions(
-    keyObject,
-    dbParams
-  );
-};
-buildUpdateExpressionQuery_fn = function(options) {
-  var _a;
-  const query = new QueryBuilderService();
-  if ((_a = options.index) == null ? void 0 : _a.indexName) query.usingIndex(options.index.indexName);
-  this.applyFilters(query, options);
-  return query;
-};
-getKeyObjectForUpdateExpression_fn = function(queryObject, primaryKeys) {
-  const keyObject = {};
-  Object.keys(queryObject.ExpressionAttributeNames).forEach(
-    (attribute) => {
-      const sanitizedAttribute = attribute.replace("#", "").replace("1", "");
-      if (primaryKeys.includes(sanitizedAttribute)) {
-        const valueName = `:${sanitizedAttribute}1`;
-        keyObject[sanitizedAttribute] = queryObject.ExpressionAttributeValues[valueName];
-        delete queryObject.ExpressionAttributeValues[valueName];
-        delete queryObject.ExpressionAttributeNames[attribute];
-      }
-    }
-  );
-  return keyObject;
-};
-getUpdateExpressionOptions_fn = function(options) {
-  const updateExprOptions = {
-    ReturnValues: options.returnValues
-  };
-  if (options.expressionAttributeNames)
-    updateExprOptions.ExpressionAttributeNames = options.expressionAttributeNames;
-  if (options.expressionAttributeValues)
-    updateExprOptions.ExpressionAttributeValues = options.expressionAttributeValues;
-  return updateExprOptions;
-};
-extractUpdateExpressionAttributesAndNames_fn = function(actions, actionType) {
-  const actionUpdateExpressions = [];
-  actions[actionType].forEach((action) => {
-    switch (actionType) {
-      case DYNAMO_DB_UPDATE_ACTIONS.DELETE:
-      case DYNAMO_DB_UPDATE_ACTIONS.REMOVE:
-        actionUpdateExpressions.push(`${action.path}`);
-        break;
-      case DYNAMO_DB_UPDATE_ACTIONS.ADD:
-      case DYNAMO_DB_UPDATE_ACTIONS.SET:
-        {
-          let operator = "";
-          if (actionType == DYNAMO_DB_UPDATE_ACTIONS.SET)
-            operator = "=";
-          actionUpdateExpressions.push(
-            `${action.path} ${operator}${action.value}`
-          );
-        }
-        break;
-    }
-  });
-  const actionUpdateExpression = `${actionType} ${actionUpdateExpressions.join(
-    ", "
-  )}`;
-  return actionUpdateExpression;
-};
-
-export { DynamoDbCrudService };
-//# sourceMappingURL=dynamoDbCrud.service-NRSGRPDQ.mjs.map
-//# sourceMappingURL=dynamoDbCrud.service-NRSGRPDQ.mjs.map