@qrvey/data-persistence 0.5.8 → 0.5.9-bundled

package/dist/esm/index.mjs

@@ -1,5 +1,110 @@
-import { FILTER_LOGIC_OPERATORS, CONNECTION_CLOSING_MODES, __spreadValues, __objRest, isMultiPlatformMode, __spreadProps } from './chunk-2OYWEFNZ.mjs';
-import { Pool } from 'pg';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient, GetCommand, QueryCommand, ScanCommand, PutCommand, UpdateCommand, DeleteCommand, BatchWriteCommand } from '@aws-sdk/lib-dynamodb';
+import { literal, ident, format } from '@scaleleap/pg-format';
+import { Pool, Client } from 'pg';
+export { Pool } from 'pg';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/utils/constants.ts
+var FILTER_OPERATOR_MAP = {
+  CONTAINS: "contains",
+  NOT_CONTAINS: "notContains",
+  EQUAL: "eq",
+  STARTS_WITH: "beginsWith",
+  NOT_EQUAL: "notEq",
+  IN: "in",
+  GREATER_THAN: "gt",
+  GT: "gt",
+  GREATER_THAN_EQUAL: "gte",
+  GTE: "gte",
+  LESS_THAN: "lt",
+  LT: "lt",
+  LESS_THAN_EQUAL: "lte",
+  LTE: "lte",
+  EXIST: "attribute_exists",
+  NOT_EXIST: "attribute_not_exists",
+  BETWEEN: "between"
+};
+var DYNAMODB_OPERATORS = {
+  EQUAL: "EQUAL"
+};
+var CONNECTION_CLOSING_MODES = /* @__PURE__ */ ((CONNECTION_CLOSING_MODES2) => {
+  CONNECTION_CLOSING_MODES2["AUTO"] = "AUTO";
+  CONNECTION_CLOSING_MODES2["MANUAL"] = "MANUAL";
+  return CONNECTION_CLOSING_MODES2;
+})(CONNECTION_CLOSING_MODES || {});
+var FILTER_LOGIC_OPERATORS = /* @__PURE__ */ ((FILTER_LOGIC_OPERATORS2) => {
+  FILTER_LOGIC_OPERATORS2["AND"] = "AND";
+  FILTER_LOGIC_OPERATORS2["OR"] = "OR";
+  return FILTER_LOGIC_OPERATORS2;
+})(FILTER_LOGIC_OPERATORS || {});
+var POSTGRES_FILTER_OPERATOR_MAP = {
+  EQUAL: "=",
+  NOT_EQUAL: "<>",
+  GREATER_THAN: ">",
+  GT: ">",
+  GTE: ">=",
+  GREATER_THAN_EQUAL: ">=",
+  LTE: "<=",
+  LESS_THAN_EQUAL: "<=",
+  LESS_THAN: "<",
+  LT: "<",
+  IN: "IN",
+  STARTS_WITH: "LIKE",
+  CONTAINS: "LIKE",
+  NOT_CONTAINS: "NOT LIKE",
+  BETWEEN: "BETWEEN",
+  EXIST: "IS NOT NULL",
+  NOT_EXIST: "IS NULL"
+};
+var DEFAULT_PG_SCHEMA = "public";
+var DYNAMO_DB_UPDATE_ACTIONS = {
+  SET: "SET",
+  ADD: "ADD",
+  DELETE: "DELETE",
+  REMOVE: "REMOVE"
+};
+function isMultiPlatformMode() {
+  var _a;
+  return ((_a = process.env.PLATFORM_TYPE) == null ? void 0 : _a.toLowerCase()) === "container";
+}
 
 // src/helpers/crudHelpers.ts
 function buildFilter(attribute, value, operator = "EQUAL", relativePath = void 0) {
@@ -22,21 +127,1701 @@ function buildSort(column, direction = "ASC" /* ASC */) {
     direction
   };
 }
+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/helpers/queryHelpers.ts
+function buildAggFunctionAlias(aggregateFunction) {
+  return `AGG_FN_${aggregateFunction}`;
+}
+
+// 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/helpers/tableHelper.ts
+function getTableColumnNames(columns) {
+  return Object.keys(columns);
+}
+function findIdColumnName(columns) {
+  return getTableColumnNames(columns).find(
+    (columnName) => columns[columnName].columnId === true
+  );
+}
+function getTableName(table, property = "name") {
+  if (!table) throw new Error("missing table property");
+  if (typeof table === "string") return table;
+  const { name, alias } = table;
+  return property === "alias" && alias ? alias : name;
+}
+function getPrimaryKeyColumns(columns) {
+  return getTableColumnNames(columns).filter(
+    (columnName) => columns[columnName].primary === true
+  );
+}
+
+// src/error/NoRecordsAffectedException.ts
+var NoRecordsAffectedException = class extends Error {
+  constructor() {
+    super("No records affected by update");
+    this.name = "NoRecordsAffectedException";
+  }
+};
+
+// src/helpers/errorHelper.ts
+function PersistenceErrorWrapper(queryResult) {
+  const dynamoNoRecordsAffectedExceptions = [
+    "ConditionalCheckFailedException"
+  ];
+  if (queryResult instanceof Error) {
+    if (queryResult.name && dynamoNoRecordsAffectedExceptions.includes(queryResult.name)) {
+      throw new NoRecordsAffectedException();
+    } else {
+      throw queryResult;
+    }
+  } else {
+    if (queryResult.rowCount === 0) {
+      throw new NoRecordsAffectedException();
+    }
+  }
+  return queryResult;
+}
+
+// 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, { skipFindItems = false }) {
+    const savedRecord = skipFindItems ? {} : 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;
+};
+var ConnectionService = class {
+  get connectionString() {
+    const connectionString = process.env.MULTIPLATFORM_PG_CONNECTION_STRING || "";
+    if (!connectionString) {
+      throw new Error(
+        "MULTIPLATFORM_PG_CONNECTION_STRING environment variable must be configured"
+      );
+    }
+    return connectionString;
+  }
+  async getClient() {
+    const client = new Client({
+      connectionString: this.connectionString
+    });
+    await client.connect();
+    return client;
+  }
+  releaseClient(client) {
+    try {
+      client.end();
+    } catch (e) {
+      console.log("Error releasing client");
+    }
+  }
+};
+
+// src/services/cruds/postgresql/query.service.ts
+var QueryService = class {
+  constructor(pool) {
+    this.pool = pool;
+    this.connectionService = new ConnectionService();
+  }
+  async runQuery(queryText, values) {
+    const client = await (this.pool ? this.pool.connect() : this.connectionService.getClient());
+    try {
+      if (process.env.NODE_ENV === "development")
+        console.info("[data-persistence] Query as Text:", queryText);
+      const result = await client.query(queryText, values);
+      return result;
+    } finally {
+      if (this.pool) {
+        await client.release();
+      } else {
+        this.connectionService.releaseClient(client);
+      }
+    }
+  }
+};
+
+// src/services/cruds/postgresql/postgreSqlClient.service.ts
+var PostgresqlClientService = class extends QueryService {
+  constructor(tableSchema, poolClient) {
+    super(poolClient);
+    this.isCompositeFilter = function(value) {
+      return "OR" in value || "AND" in value;
+    };
+    this.crudSchema = tableSchema;
+  }
+  get dbSchema() {
+    return this.crudSchema.schema || DEFAULT_PG_SCHEMA;
+  }
+  get tableName() {
+    return getTableName(this.crudSchema.table, "alias") || getTableName(this.crudSchema.table);
+  }
+  get isTemporalTable() {
+    var _a;
+    return (_a = this.crudSchema) == null ? void 0 : _a.isTemporalTable;
+  }
+  getWildcardValue(operator, value) {
+    if (operator === "CONTAINS" /* CONTAINS */ || operator === "NOT_CONTAINS" /* NOT_CONTAINS */) {
+      return "%" + value + "%";
+    } else if (operator === "STARTS_WITH" /* STARTS_WITH */) {
+      return value + "%";
+    } else {
+      return value;
+    }
+  }
+  buildClause(operator, attribute, relativePath, value) {
+    var _a;
+    const formattedValue = literal(value);
+    operator = operator ? operator.toUpperCase() : "EQUAL" /* EQUAL */;
+    const postgresOperator = POSTGRES_FILTER_OPERATOR_MAP[operator];
+    if (!postgresOperator)
+      throw new Error(`Unsupported filter operator: ${operator}`);
+    let property;
+    const filterProperty = ident(attribute);
+    const columnExists = !!this.crudSchema.columns[attribute];
+    const columnType = columnExists && ((_a = this.crudSchema.columns[attribute]) == null ? void 0 : _a.type);
+    if (relativePath != void 0) {
+      const attributePath = relativePath.split(".").join(",");
+      property = `("${attribute}" #> '{${attributePath}}')`;
+      if (value != null) {
+        const comparisonValueType = this.getValueTypeAsPostgresDefinition(value);
+        property += `::${comparisonValueType}`;
+      }
+    } else {
+      property = columnExists ? filterProperty : `("qvAttributes" ->> '${attribute}')`;
+    }
+    if (operator === "IN" /* IN */) {
+      const formattedValues = Array.isArray(value) ? value.map(literal) : [formattedValue];
+      return `${property} ${postgresOperator} (${formattedValues.join(
+        ", "
+      )})`;
+    }
+    if (operator === "BETWEEN" /* BETWEEN */) {
+      return `${property} ${postgresOperator} ${value[0]} AND ${value[1]}`;
+    }
+    if (operator === "NOT_EQUAL" /* NOT_EQUAL */ && value !== null) {
+      return `(${property} ${postgresOperator} ${literal(
+        value
+      )} OR ${property} IS NULL)`;
+    }
+    if (operator === "NOT_EXIST" /* NOT_EXIST */ || operator === "EXIST" /* EXIST */) {
+      return `${property} ${postgresOperator}`;
+    }
+    if ((operator === "CONTAINS" /* CONTAINS */ || operator === "NOT_CONTAINS" /* NOT_CONTAINS */) && columnType === "array") {
+      const filterValue = typeof value === "number" ? value : `'${value}'`;
+      let filterString = `${filterValue} = ANY(${property})`;
+      if (operator === "NOT_CONTAINS" /* NOT_CONTAINS */) {
+        if (value === null) {
+          filterString = `(NOT (${filterString}))`;
+        } else {
+          filterString = `(NOT (${filterString}) or ${property} IS NULL)`;
+        }
+      }
+      return filterString;
+    }
+    const wildcardValue = this.getWildcardValue(operator, value);
+    return `${property} ${postgresOperator} ${literal(wildcardValue)}`;
+  }
+  buildFilterClause(filters, logicOperator) {
+    if (Array.isArray(filters)) {
+      const filterClauses = filters.map((filter) => {
+        return this.buildClause(
+          filter.operator,
+          filter.attribute,
+          filter.relativePath,
+          filter.value
+        );
+      });
+      return filterClauses.join(
+        ` ${logicOperator != null ? logicOperator : "AND" /* AND */} `
+      );
+    } else {
+      return this.buildQueryByClause(filters);
+    }
+  }
+  buildQueryByClause(filters) {
+    let filterClauses = "";
+    let isFirstFilter = true;
+    for (const [key, value] of Object.entries(filters)) {
+      if (!isFirstFilter) {
+        filterClauses += key === "AND" ? " AND " : " OR ";
+      }
+      if (this.isCompositeFilter(value)) {
+        filterClauses += "(";
+        filterClauses += this.buildQueryByClause(
+          value
+        );
+        filterClauses += ")";
+      } else {
+        value.forEach((filter) => {
+          let clause = "";
+          if (this.isCompositeFilter(filter)) {
+            clause = `(${this.buildQueryByClause(
+              filter
+            )})`;
+          } else {
+            clause = this.buildClause(
+              filter.operator,
+              filter.attribute,
+              filter.relativePath,
+              filter.value
+            );
+          }
+          filterClauses += `${clause} ${key} `;
+        });
+      }
+      isFirstFilter = false;
+    }
+    filterClauses = filterClauses.replace(/\s+(AND|OR)\s*$/, "");
+    return filterClauses;
+  }
+  formatOrderByItem(sort) {
+    return `${ident(sort.column)} ${sort.direction || "ASC" /* ASC */}`;
+  }
+  buildOrderByClause(querySorting) {
+    try {
+      return querySorting.map(this.formatOrderByItem).join(", ");
+    } catch (error) {
+      return "";
+    }
+  }
+  formatArray(array) {
+    const isNumberArray = typeof array[0] === "number";
+    if (isNumberArray) {
+      return `{${array.join(",")}}`;
+    } else {
+      return `{${array.map((val) => `"${val}"`).join(",")}}`;
+    }
+  }
+  formatValue(value) {
+    if (Array.isArray(value)) {
+      if (!(value == null ? void 0 : value.length)) return "{}";
+      const isNumberArray = typeof value[0] === "number";
+      if (isNumberArray) {
+        return `{${value.join(",")}}`;
+      } else {
+        return `{${value.map((val) => `"${val}"`).join(",")}}`;
+      }
+    }
+    return value;
+  }
+  async createCommand(data) {
+    const keys = Object.keys(data[0]);
+    const values = data.map(
+      (item) => keys.map((key) => this.formatValue(item[key]))
+    );
+    const query = format(
+      `INSERT INTO ${ident(this.dbSchema)}.${ident(
+        this.tableName
+      )} (%I) VALUES %L RETURNING *;`,
+      keys,
+      values
+    );
+    return this.runQuery(query);
+  }
+  isValidFiltersInput(filters) {
+    const isValidArrayFilters = Array.isArray(filters) && (filters == null ? void 0 : filters.length) > 0;
+    const isValidCompositeFilters = this.isCompositeFilter(filters);
+    return isValidArrayFilters || isValidCompositeFilters;
+  }
+  replaceFilterTokensInQuery(query, filters) {
+    if (!filters) return query;
+    if (this.isValidFiltersInput(filters)) {
+      const filterClause = this.buildFilterClause(filters);
+      return query.replace(/{{filters}}/g, filterClause);
+    }
+  }
+  addFiltersToQuery(query, filters) {
+    if (!filters) return query;
+    if (this.isValidFiltersInput(filters))
+      query += ` WHERE ${this.buildFilterClause(filters)}`;
+    return query;
+  }
+  addOrderByToQuery(query, orderBy) {
+    if (orderBy) query += ` ORDER BY ${this.buildOrderByClause(orderBy)}`;
+    return query;
+  }
+  addPaginationToQuery(query, pagination) {
+    if (pagination) {
+      const { limit, from } = pagination;
+      if (limit) query += ` LIMIT ${limit}`;
+      if (from) query += ` OFFSET ${from}`;
+    }
+    return query;
+  }
+  getSelectClause(aggregateFunction, fields = []) {
+    if (aggregateFunction)
+      return `CAST(${aggregateFunction}(1) AS INTEGER) AS "${buildAggFunctionAlias(
+        aggregateFunction
+      )}"`;
+    if (!(fields == null ? void 0 : fields.length)) return "*";
+    return this.parseFields(fields).join(", ");
+  }
+  parseFields(fields) {
+    const columnsFromSchema = Object.keys(
+      this.crudSchema.columns
+    );
+    const attributes = fields.filter((field) => columnsFromSchema.indexOf(field) !== -1).map((field) => `"${field}"`);
+    fields.filter((field) => columnsFromSchema.indexOf(field) === -1).forEach((field) => {
+      attributes.push(`"qvAttributes" ->> '${field}' as "${field}"`);
+    });
+    return attributes;
+  }
+  resolveWithQueries(rawWith) {
+    const withQueries = rawWith.map(({ alias, query, filters }) => {
+      const withQuery = this.replaceFilterTokensInQuery(query, filters);
+      return `${alias} AS (${withQuery})`;
+    });
+    return withQueries;
+  }
+  getRawWithClause(rawWith) {
+    let rawWithClause = "";
+    if (rawWith == null ? void 0 : rawWith.length) {
+      const withQueries = this.resolveWithQueries(rawWith);
+      rawWithClause = "WITH " + withQueries.join(",\n");
+    }
+    return rawWithClause;
+  }
+  getQueryFrom() {
+    return this.isTemporalTable ? ident(this.tableName) : `${ident(this.dbSchema)}.${ident(this.tableName)}`;
+  }
+  async findCommand(options = {}) {
+    const rawWithClause = this.getRawWithClause(options.rawWith);
+    let query = `SELECT ${this.getSelectClause(
+      options.aggregateFunction,
+      options.fields
+    )} FROM ${this.getQueryFrom()}`;
+    query = this.addFiltersToQuery(query, options.filters);
+    if (!options.aggregateFunction) {
+      query = this.addOrderByToQuery(query, options.sorting);
+      query = this.addPaginationToQuery(query, options.pagination);
+    }
+    if (rawWithClause) {
+      query = `${rawWithClause} ${query}`;
+    }
+    return (await this.runQuery(query)).rows;
+  }
+  sanitizeValue(value) {
+    if (Array.isArray(value)) {
+      if (value.length === 0) ;
+      const formattedArray = value.map((item) => {
+        if (typeof item === "string") {
+          return `'${item}'`;
+        } else if (typeof item === "object") {
+          return JSON.stringify(item);
+        } else {
+          return item;
+        }
+      }).join(",");
+      return JSON.stringify(formattedArray);
+    } else {
+      return literal(value);
+    }
+  }
+  async updateCommand(filters, data) {
+    let query = `UPDATE ${ident(this.dbSchema)}.${ident(
+      this.tableName
+    )} SET`;
+    const updateClauses = Object.entries(data).map(([key, value]) => {
+      const dbValue = literal(this.formatValue(value));
+      return `${ident(key)} = ${dbValue}`;
+    });
+    query += ` ${updateClauses.join(", ")}`;
+    query += " WHERE ";
+    query += this.buildFilterClause(filters);
+    return this.runQuery(query);
+  }
+  buildFilterClauseForFilterGroups(filterGroups) {
+    const filterClauses = filterGroups.map((filterGroup) => {
+      return `(${this.buildFilterClause(filterGroup)})`;
+    });
+    return filterClauses.join(" OR ");
+  }
+  async deleteCommand(filters, useFilterGroups = false) {
+    let query = `DELETE FROM ${ident(this.dbSchema)}.${ident(
+      this.tableName
+    )}`;
+    if (filters) {
+      query += " WHERE ";
+      if (useFilterGroups) {
+        query += this.buildFilterClauseForFilterGroups(
+          filters
+        );
+      } else {
+        query += this.buildFilterClause(
+          filters
+        );
+      }
+    }
+    return this.runQuery(query);
+  }
+  query(queryText, values) {
+    return this.runQuery(queryText, values);
+  }
+  async updateExpressionCommand(filters, actions, options = {}) {
+    let query = `UPDATE ${ident(this.dbSchema)}.${ident(
+      this.tableName
+    )} SET`;
+    const set = actions.SET || [];
+    const add = actions.ADD || [];
+    const columns = this.crudSchema.columns;
+    const setValues = this.replacePathAndValueByAttributeNames(
+      set,
+      options,
+      columns,
+      DYNAMO_DB_UPDATE_ACTIONS.SET
+    );
+    const addValues = this.replacePathAndValueByAttributeNames(
+      add,
+      options,
+      columns,
+      DYNAMO_DB_UPDATE_ACTIONS.ADD
+    );
+    const setValuesAndAddValues = setValues.concat(addValues);
+    const updateClauses = [];
+    const jsonSetExpressionGroup = {};
+    const queryFunctions = [];
+    setValuesAndAddValues.forEach((expression) => {
+      const { path, value, createNewColumn, actionName, dynamoFuncName } = expression;
+      if (dynamoFuncName) {
+        queryFunctions.push({ path, value, dynamoFuncName });
+      }
+      if (path.includes(".") && !dynamoFuncName) {
+        const jsonExpr = this.getJSONBSetExpressionByAction(
+          path,
+          value,
+          {
+            createNewColumn,
+            actionName
+          }
+        );
+        const columnName = jsonExpr.columnName;
+        if (!jsonSetExpressionGroup[columnName]) {
+          jsonSetExpressionGroup[columnName] = [jsonExpr];
+        } else {
+          jsonSetExpressionGroup[columnName].push(jsonExpr);
+        }
+      } else if (!dynamoFuncName) {
+        let expValue;
+        const column = this.crudSchema.columns[path];
+        if ((column == null ? void 0 : column.type) == void 0)
+          throw `Column type definition for column: (${path}) must be in the CrudSchema`;
+        let formattedValue;
+        switch (column.type) {
+          case "object":
+            {
+              const valueSerialized = `${JSON.stringify(
+                value
+              ).replace(/'/g, "''")}`;
+              expValue = `'${valueSerialized}'::jsonb`;
+            }
+            break;
+          case "array":
+            formattedValue = literal(value);
+            expValue = `ARRAY[${formattedValue}]`;
+            break;
+          default:
+            formattedValue = literal(value);
+            expValue = formattedValue;
+            break;
+        }
+        this.crudSchema.columns;
+        updateClauses.push(`${ident(path)} = ${expValue}`);
+      }
+    });
+    this.setCommonColumnsQueryFunctions(
+      jsonSetExpressionGroup,
+      queryFunctions
+    );
+    if (Object.keys(jsonSetExpressionGroup).length > 0) {
+      Object.keys(jsonSetExpressionGroup).forEach((groupIndex) => {
+        const jsonSetExpression = this.buildJSONBExpression(
+          jsonSetExpressionGroup[groupIndex],
+          "jsonb_set"
+        );
+        updateClauses.push(`${groupIndex} = ${jsonSetExpression}`);
+      });
+    }
+    this.buildUpdateClausesFormDynamoFunctions(
+      queryFunctions,
+      updateClauses
+    );
+    query += ` ${updateClauses.join(", ")}`;
+    query += " WHERE ";
+    query += this.buildFilterClause(filters);
+    return this.runQuery(query);
+  }
+  buildUpdateClausesFormDynamoFunctions(queryFunctions, updateClauses) {
+    if (queryFunctions.length > 0) {
+      queryFunctions.forEach((queryFunction) => {
+        if (typeof queryFunction.value == "object") {
+          const jsonExpr = this.buildJSONBExpression(
+            queryFunction.value.jsonExpression,
+            "jsonb_insert"
+          );
+          updateClauses.push(
+            `${ident(queryFunction.path)} = ${jsonExpr}`
+          );
+        } else {
+          updateClauses.push(
+            `${ident(queryFunction.path)} = ${queryFunction.value}`
+          );
+        }
+      });
+    }
+  }
+  setCommonColumnsQueryFunctions(jsonSetExpressionGroup, queryFunctions) {
+    Object.keys(jsonSetExpressionGroup).forEach((jsonSetExpr) => {
+      queryFunctions.forEach((queryFunction, index) => {
+        const columnPath = `"${queryFunction.path}"`;
+        if (columnPath === jsonSetExpr) {
+          jsonSetExpressionGroup[jsonSetExpr].push(__spreadProps(__spreadValues({}, queryFunction), {
+            isCommonColumn: true
+          }));
+          delete queryFunctions[index];
+        }
+      });
+    });
+  }
+  /**
+   * @description Builds a jsonb expression like jsonb_insert, or jsonb_set
+   * @param jsonSetExpressions
+   * @param functionName
+   * @returns
+   */
+  buildJSONBExpression(jsonSetExpressions, functionName) {
+    let jsonSetStringExpr = "";
+    jsonSetExpressions.forEach((expression, index) => {
+      let _tempFunctionName = functionName;
+      let { columnName, jsonExpr } = expression;
+      if (expression.isCommonColumn) {
+        const jsonExpression = expression.value.jsonExpression[0];
+        _tempFunctionName = jsonExpression.functionName;
+        jsonExpr = jsonExpression.jsonExpr;
+        columnName = jsonExpression.columnName;
+      }
+      if (index === 0) {
+        jsonSetStringExpr = `${_tempFunctionName}(${columnName},${jsonExpr})`;
+      } else {
+        jsonSetStringExpr = `${_tempFunctionName}(${jsonSetStringExpr},${jsonExpr})`;
+      }
+    });
+    return jsonSetStringExpr;
+  }
+  /**
+   * @description Serializes a JSON value
+   * @param value
+   * @returns
+   */
+  serializeJSONValue(value) {
+    const valueSerialized = typeof value == "object" ? `${JSON.stringify(value).replace(/'/g, "''")}` : value;
+    return valueSerialized;
+  }
+  getJSONBSetExpressionByAction(path, value, options) {
+    path = path.replace(/\[(\d+)\]/g, ".$1");
+    const pathSplitted = path.split(".");
+    const parentPath = pathSplitted[0];
+    const { createNewColumn, actionName } = options;
+    const pathSerialized = pathSplitted.slice(1).join(",");
+    const valueSerialized = `'${JSON.stringify(value).replace(
+      /'/g,
+      "''"
+    )}'`;
+    if (actionName == DYNAMO_DB_UPDATE_ACTIONS.ADD) {
+      if (typeof value != "string" && !isNaN(value)) {
+        const resultExpr = {
+          jsonExpr: `'{${pathSerialized}}',to_jsonb(COALESCE(("${parentPath}"#>'{${pathSerialized}}')::numeric,0) + ${valueSerialized})`,
+          columnName: `"${parentPath}"`
+        };
+        return resultExpr;
+      }
+    }
+    return {
+      jsonExpr: `'{${pathSerialized}}',${valueSerialized},${createNewColumn}`,
+      columnName: `"${parentPath}"`
+    };
+  }
+  getListAppendDefFromValue(queryValue, columnType) {
+    const regexListAppend = /list_append\(([^)]+)\)/gm;
+    const listAppendString = "list_append(";
+    const matchList = queryValue.match(regexListAppend) || [];
+    const groupResult = matchList[0];
+    if (groupResult) {
+      const attributesFromGroup = groupResult.slice(listAppendString.length, -1).split(",");
+      const attributes = {
+        originalString: groupResult,
+        path: attributesFromGroup[0].trim(),
+        value: attributesFromGroup.slice(1).join(",").trim(),
+        isDynamoFunction: true,
+        functionExpr: "",
+        jsonExpression: [{}]
+      };
+      if (columnType == "array") {
+        attributes["functionExpr"] = this.buildArrayAppendExpr(attributes);
+      } else {
+        attributes["jsonExpression"] = this.buildJsonbInsertExpr(attributes);
+      }
+      return attributes;
+    }
+    return null;
+  }
+  buildArrayAppendExpr(params) {
+    const arrayPath = params.path.split(".");
+    const columnName = arrayPath.shift();
+    return `ARRAY_APPEND("${columnName}",${params.value})`;
+  }
+  buildJsonbInsertExpr(params) {
+    const arrayPath = params.path.split(".");
+    const columnName = arrayPath.shift();
+    const options = {
+      isDynamoFunction: params == null ? void 0 : params.isDynamoFunction,
+      relativePath: arrayPath.length && Array.isArray(arrayPath) ? arrayPath : []
+    };
+    const jsonbInsertExpressions = this.getExpressionsByDefinitionForJSONBInsert(
+      columnName,
+      params.value,
+      options
+    );
+    return jsonbInsertExpressions;
+  }
+  getExpressionsByDefinitionForJSONBInsert(columnName, value, options) {
+    const jsonbInsertExpressions = [];
+    let pathToAffect = "0";
+    if (options.isDynamoFunction == true) {
+      options.relativePath.push("0");
+      pathToAffect = options.relativePath.join(",");
+    }
+    try {
+      const parsedValue = JSON.parse(value);
+      if (Array.isArray(parsedValue)) {
+        parsedValue.forEach((arrayValue) => {
+          arrayValue = typeof arrayValue == "string" ? `"${arrayValue}"` : arrayValue;
+          jsonbInsertExpressions.push({
+            jsonExpr: `'{${pathToAffect}}','${this.serializeJSONValue(
+              arrayValue
+            )}'`,
+            columnName: `"${columnName}"`,
+            functionName: "jsonb_insert"
+          });
+        });
+      } else {
+        jsonbInsertExpressions.push({
+          jsonExpr: `'{${pathToAffect}}','${this.serializeJSONValue(
+            parsedValue
+          )}'`,
+          columnName: `"${columnName}"`,
+          functionName: "jsonb_insert"
+        });
+      }
+    } catch (error) {
+      jsonbInsertExpressions.push({
+        jsonExpr: `'{${pathToAffect}}','${value}'`,
+        columnName: `"${columnName}"`,
+        functionName: "jsonb_insert"
+      });
+    }
+    return jsonbInsertExpressions;
+  }
+  getInsertExprFromJsonbDef(queryValue, columnType) {
+    const listAppendParams = this.getListAppendDefFromValue(
+      queryValue,
+      columnType
+    );
+    if (listAppendParams != null && (listAppendParams == null ? void 0 : listAppendParams.jsonExpression.length) === 0) {
+      queryValue = queryValue.replace(
+        listAppendParams.originalString,
+        listAppendParams.functionExpr
+      );
+    } else {
+      return listAppendParams;
+    }
+    return queryValue;
+  }
+  replacePathAndValueByAttributeNames(actions, options, columns, actionName) {
+    return actions.map((action) => {
+      action.path = this.replaceExpressionAttributeNames(
+        action.path,
+        options
+      );
+      if (typeof action.value == "string" && action.value.includes("list_append")) {
+        action.path = action.path.split(".")[0];
+        const column = columns[action.path];
+        action.value = this.replaceExpressionAttributeValuesForDynamoFunctions(
+          action.value,
+          options
+        );
+        action.value = this.getInsertExprFromJsonbDef(
+          action.value,
+          column.type
+        );
+        action.dynamoFuncName = "list_append";
+      } else {
+        action.value = this.replaceExpressionAttributeValues(
+          action.value,
+          options
+        );
+      }
+      action.actionName = actionName;
+      action.createNewColumn = true;
+      return action;
+    });
+  }
+  replaceExpressionAttributeValuesForDynamoFunctions(value, options) {
+    const { expressionAttributeNames, expressionAttributeValues } = options;
+    const exprAttributeNamesKeys = expressionAttributeNames ? Object.keys(expressionAttributeNames) : [];
+    const exprAttributeValuesKeys = expressionAttributeValues ? Object.keys(expressionAttributeValues) : [];
+    if (exprAttributeNamesKeys.length > 0) {
+      exprAttributeNamesKeys.forEach((exprAttribute) => {
+        value = value.replace(
+          exprAttribute,
+          expressionAttributeNames[exprAttribute]
+        );
+      });
+    }
+    if (exprAttributeValuesKeys.length > 0) {
+      exprAttributeValuesKeys.forEach((exprAttribute) => {
+        const valueSerialized = this.serializeJSONValue(
+          expressionAttributeValues[exprAttribute]
+        );
+        value = value.replace(exprAttribute, `${valueSerialized}`);
+      });
+    }
+    return value;
+  }
+  replaceExpressionAttributeNames(path, options) {
+    const { expressionAttributeNames } = options;
+    if (expressionAttributeNames) {
+      Object.keys(expressionAttributeNames).forEach(
+        (attributeName) => {
+          const attributeNameValue = expressionAttributeNames[attributeName];
+          path = path.replace(attributeName, attributeNameValue);
+        }
+      );
+    }
+    return path;
+  }
+  replaceExpressionAttributeValues(value, options) {
+    const { expressionAttributeValues } = options;
+    if (expressionAttributeValues[value] != void 0) {
+      return expressionAttributeValues[value];
+    }
+    return value;
+  }
+  getValueTypeAsPostgresDefinition(value) {
+    switch (typeof value) {
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "string":
+      default:
+        return "text";
+    }
+  }
+};
+
+// src/services/cruds/postgresql/postgreSqlCrud.service.ts
+var PostgreSqlCrudService = class extends PostgresqlClientService {
+  constructor(tableSchema, poolClient) {
+    super(tableSchema, poolClient);
+    this.tableSchema = tableSchema;
+  }
+  get idColumnName() {
+    return findIdColumnName(this.tableSchema.columns);
+  }
+  normalizeInputData(inputData) {
+    var _a;
+    inputData.qvAttributes = {};
+    for (const key in inputData) {
+      if (!this.tableSchema.columns[key] && key !== "qvAttributes") {
+        inputData.qvAttributes[key] = inputData[key];
+        delete inputData[key];
+      } else if (Array.isArray(inputData[key]) && ((_a = this.tableSchema.columns[key]) == null ? void 0 : _a.type) !== "array") {
+        inputData[key] = JSON.stringify(inputData[key]);
+      }
+    }
+  }
+  getItem(data) {
+    const schemaColumns = Object.entries(this.tableSchema.columns);
+    schemaColumns.forEach(([key, value]) => {
+      if (value.type === "big_number") {
+        if (data[key]) data[key] = Number(data[key]);
+      }
+    });
+    const resultItem = __spreadValues(__spreadValues({}, data), data.qvAttributes);
+    delete resultItem["qvAttributes"];
+    return resultItem;
+  }
+  prepareData(data) {
+    const inputData = __spreadValues({}, data);
+    this.normalizeInputData(inputData);
+    return inputData;
+  }
+  buildCreateResponseBatch(result) {
+    const rows = Array.isArray(result == null ? void 0 : result.rows) ? result.rows : [];
+    return {
+      items: rows.map((r) => this.getItem(r)),
+      unprocessedItems: []
+    };
+  }
+  create(data) {
+    if (Array.isArray(data)) {
+      const inputDataArray = data.map((item) => this.prepareData(item));
+      return this.createCommand(inputDataArray).then((result) => {
+        return this.buildCreateResponseBatch(result);
+      });
+    } else {
+      const inputData = this.prepareData(data);
+      return this.createCommand([inputData]).then(
+        (result) => result.rowCount ? this.getItem(result.rows[0]) : null
+      );
+    }
+  }
+  findItem(findOptions) {
+    return this.findCommand(findOptions).then((data) => {
+      return (data == null ? void 0 : data.length) ? this.getItem(data[0]) : null;
+    });
+  }
+  async processQueryResult(findOptions, omitPagination = false) {
+    const rows = await this.findCommand(findOptions);
+    const items = rows.map(
+      (row) => this.getItem(row)
+    );
+    const { limit, from } = (findOptions == null ? void 0 : findOptions.pagination) || {};
+    const hasMoreRecords = items.length && items.length === limit;
+    const newFrom = limit && hasMoreRecords ? limit + (from || 0) : null;
+    const result = {
+      items,
+      pagination: omitPagination ? null : { limit, from: newFrom },
+      count: items.length
+    };
+    return result;
+  }
+  async find(findOptions) {
+    return this.processQueryResult(findOptions);
+  }
+  async findAll(findOptions) {
+    return this.processQueryResult(findOptions, true);
+  }
+  async findCount(findOptions) {
+    const items = await this.findCommand(__spreadProps(__spreadValues({}, findOptions), {
+      aggregateFunction: "COUNT" /* COUNT */
+    }));
+    const aggFunctionProperty = buildAggFunctionAlias(
+      "COUNT" /* COUNT */
+    );
+    const item = items.length ? items[0] : {};
+    return item[aggFunctionProperty] || 0;
+  }
+  async update(filters, data, options = {}) {
+    const savedRecord = options.skipFindItems ? {} : await this.findItem({ filters });
+    const inputData = __spreadValues(__spreadValues({}, savedRecord), data);
+    await this.updateCommand(filters, this.prepareData(inputData));
+    return this.getItem(inputData);
+  }
+  async remove(filters, options) {
+    await this.deleteCommand(filters, options == null ? void 0 : options.filterGroups);
+  }
+  runQuery(querySentence, values) {
+    return super.runQuery(querySentence, values);
+  }
+  async updateExpressions(filters, actions, options) {
+    const result = await this.updateExpressionCommand(
+      filters,
+      actions,
+      options
+    );
+    return PersistenceErrorWrapper(result);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  runRawQuery(query, params) {
+    throw super.runQuery(query, params);
+  }
+};
 
 // src/services/crudFactory.service.ts
 var CrudFactory = class {
-  static async databaseClientService(crudSchema, pool) {
+  static databaseClientService(crudSchema, pool) {
     var _a;
     const isMultiPlatformMode2 = ((_a = process.env.PLATFORM_TYPE) == null ? void 0 : _a.toLowerCase()) === "container";
-    let DatabaseCrudService;
-    if (isMultiPlatformMode2) {
-      const module = await import('./postgreSqlCrud.service-AD2CHR2Z.mjs');
-      DatabaseCrudService = module.PostgreSqlCrudService;
-    } else {
-      const module = await import('./dynamoDbCrud.service-NRSGRPDQ.mjs');
-      DatabaseCrudService = module.DynamoDbCrudService;
-    }
-    return new DatabaseCrudService(crudSchema, pool);
+    if (isMultiPlatformMode2)
+      return new PostgreSqlCrudService(crudSchema, pool);
+    return new DynamoDbCrudService(crudSchema);
   }
 };
 
@@ -85,9 +1870,9 @@ var CrudService = class {
       (crudService) => crudService.findItem(options)
     );
   }
-  update(filters, data) {
+  update(filters, data, options = {}) {
     return this.getCrudServiceInstance().then(
-      (crudService) => crudService.update(filters, data, {})
+      (crudService) => crudService.update(filters, data, options)
     );
   }
   remove(filters, options = {}) {