@qrvey/data-persistence 0.5.18-796 → 0.5.19-831-beta

package/dist/esm/index.mjs

@@ -26,6 +26,7 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
@@ -38,6 +39,7 @@ var __objRest = (source, exclude) => {
     }
   return target;
 };
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 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);
@@ -65,16 +67,32 @@ var FILTER_OPERATOR_MAP = {
 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) => {
+var SORT_DIRECTIONS = /* @__PURE__ */ (function(SORT_DIRECTIONS2) {
+  SORT_DIRECTIONS2["ASC"] = "ASC";
+  SORT_DIRECTIONS2["DESC"] = "DESC";
+  return SORT_DIRECTIONS2;
+})({});
+var FILTER_LOGIC_OPERATORS = /* @__PURE__ */ (function(FILTER_LOGIC_OPERATORS2) {
   FILTER_LOGIC_OPERATORS2["AND"] = "AND";
   FILTER_LOGIC_OPERATORS2["OR"] = "OR";
   return FILTER_LOGIC_OPERATORS2;
-})(FILTER_LOGIC_OPERATORS || {});
+})({});
+var FilterOperator = /* @__PURE__ */ (function(FilterOperator2) {
+  FilterOperator2["EQUAL"] = "EQUAL";
+  FilterOperator2["NOT_EQUAL"] = "NOT_EQUAL";
+  FilterOperator2["CONTAINS"] = "CONTAINS";
+  FilterOperator2["GREATER_THAN"] = "GREATER_THAN";
+  FilterOperator2["GREATER_THAN_EQUAL"] = "GREATER_THAN_EQUAL";
+  FilterOperator2["LESS_THAN"] = "LESS_THAN";
+  FilterOperator2["LESS_THAN_EQUAL"] = "LESS_THAN_EQUAL";
+  FilterOperator2["IN"] = "IN";
+  FilterOperator2["STARTS_WITH"] = "STARTS_WITH";
+  FilterOperator2["NOT_CONTAINS"] = "NOT_CONTAINS";
+  FilterOperator2["BETWEEN"] = "BETWEEN";
+  FilterOperator2["EXIST"] = "EXIST";
+  FilterOperator2["NOT_EXIST"] = "NOT_EXIST";
+  return FilterOperator2;
+})({});
 var POSTGRES_FILTER_OPERATOR_MAP = {
   EQUAL: "=",
   NOT_EQUAL: "<>",
@@ -95,6 +113,10 @@ var POSTGRES_FILTER_OPERATOR_MAP = {
   NOT_EXIST: "IS NULL"
 };
 var DEFAULT_PG_SCHEMA = "public";
+var AGGREGATE_FUNCTIONS = /* @__PURE__ */ (function(AGGREGATE_FUNCTIONS2) {
+  AGGREGATE_FUNCTIONS2["COUNT"] = "COUNT";
+  return AGGREGATE_FUNCTIONS2;
+})({});
 var DYNAMO_DB_UPDATE_ACTIONS = {
   SET: "SET",
   ADD: "ADD",
@@ -102,12 +124,14 @@ var DYNAMO_DB_UPDATE_ACTIONS = {
   REMOVE: "REMOVE"
 };
 function isMultiPlatformMode() {
-  var _a;
-  return ((_a = process.env.PLATFORM_TYPE) == null ? void 0 : _a.toLowerCase()) === "container";
+  var _a2;
+  return ((_a2 = process.env.PLATFORM_TYPE) == null ? void 0 : _a2.toLowerCase()) === "container";
 }
+__name(isMultiPlatformMode, "isMultiPlatformMode");
 function getConnectionAlias() {
   return process.env.PG_CONNECTION_ALIAS || process.env.HOSTNAME || process.env.SERVICE_NAME || "qrvey-service";
 }
+__name(getConnectionAlias, "getConnectionAlias");
 
 // src/helpers/crudHelpers.ts
 function buildFilter(attribute, value, operator = "EQUAL", relativePath = void 0) {
@@ -118,27 +142,31 @@ function buildFilter(attribute, value, operator = "EQUAL", relativePath = void 0
     relativePath
   };
 }
+__name(buildFilter, "buildFilter");
 function buildQueryIndex(indexName, columns) {
   return {
     indexName,
     columns
   };
 }
-function buildSort(column, direction = "ASC" /* ASC */) {
+__name(buildQueryIndex, "buildQueryIndex");
+function buildSort(column, direction = SORT_DIRECTIONS.ASC) {
   return {
     column,
     direction
   };
 }
+__name(buildSort, "buildSort");
 var AWS_REGION = process.env.AWS_DEFAULT_REGION;
-var DynamoDbClientService = class {
+var _DynamoDbClientService = class _DynamoDbClientService {
   constructor(tableName) {
-    if (!tableName)
-      throw new Error(
-        'The "tableName" is required to use a DynamoDbClientService.'
-      );
+    __publicField(this, "tableName");
+    __publicField(this, "dynamoDBClient");
+    if (!tableName) throw new Error('The "tableName" is required to use a DynamoDbClientService.');
     this.tableName = tableName;
-    const client = new DynamoDBClient({ region: AWS_REGION });
+    const client = new DynamoDBClient({
+      region: AWS_REGION
+    });
     this.dynamoDBClient = DynamoDBDocumentClient.from(client, {
       marshallOptions: {
         removeUndefinedValues: true
@@ -268,23 +296,36 @@ var DynamoDbClientService = class {
     return await this.dynamoDBClient.send(new UpdateCommand(params));
   }
 };
+__name(_DynamoDbClientService, "DynamoDbClientService");
+var DynamoDbClientService = _DynamoDbClientService;
 
 // src/helpers/queryHelpers.ts
+var METHOD_TO_QUERY = /* @__PURE__ */ (function(METHOD_TO_QUERY2) {
+  METHOD_TO_QUERY2["where"] = "where";
+  METHOD_TO_QUERY2["filter"] = "filter";
+  METHOD_TO_QUERY2["update"] = "update";
+  return METHOD_TO_QUERY2;
+})({});
 function buildAggFunctionAlias(aggregateFunction) {
   return `AGG_FN_${aggregateFunction}`;
 }
+__name(buildAggFunctionAlias, "buildAggFunctionAlias");
 
 // src/services/cruds/dynamodb/queryBuilderCondition.service.ts
-var QueryBuilderConditionService = class {
+var _QueryBuilderConditionService = class _QueryBuilderConditionService {
   constructor(query) {
-    this.tempKey = "";
-    this.tempLogicOperator = null;
-    this.wheres = [];
-    this.filters = [];
-    this.updates = [];
-    this.attributeNames = {};
+    __publicField(this, "query");
+    __publicField(this, "command");
+    __publicField(this, "queryFrom");
+    __publicField(this, "tempKey", "");
+    __publicField(this, "tempLogicOperator", null);
+    __publicField(this, "config");
+    __publicField(this, "wheres", []);
+    __publicField(this, "filters", []);
+    __publicField(this, "updates", []);
+    __publicField(this, "attributeNames", {});
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    this.attributeValues = {};
+    __publicField(this, "attributeValues", {});
     this.query = query;
     this.command = {};
   }
@@ -311,49 +352,69 @@ var QueryBuilderConditionService = class {
   eq(keyValue) {
     const { key, value } = this.generateKeyValue(keyValue);
     let expression = `${key} = ${value}`;
-    if (this.tempLogicOperator)
-      expression = { expression, logicOperator: this.tempLogicOperator, config: this.config };
+    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 };
+    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 };
+    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 };
+    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 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 };
+    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 };
+    if (this.tempLogicOperator) expression = {
+      expression,
+      logicOperator: this.tempLogicOperator,
+      config: this.config
+    };
     this.setExpression(expression);
     return this.query;
   }
@@ -365,70 +426,88 @@ var QueryBuilderConditionService = class {
   gt(keyValue) {
     const { key, value } = this.generateKeyValue(keyValue);
     let expression = `${key} > ${value}`;
-    if (this.tempLogicOperator)
-      expression = { expression, logicOperator: this.tempLogicOperator, config: this.config };
+    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 };
+    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 };
+    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 };
+    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 };
+    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 };
+    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."
-      );
+    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 };
+    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 */:
+      case METHOD_TO_QUERY.filter:
         this.filters.push(expression);
         break;
-      case "update" /* update */:
+      case METHOD_TO_QUERY.update:
         this.updates.push(expression);
         break;
       default:
@@ -459,23 +538,25 @@ var QueryBuilderConditionService = class {
           if (index === valueExpression) valueExpression += "1";
         }
       }
-      if (!omitAttributeValues)
-        this.attributeValues[valueExpression] = value;
-      return { key: keyExpression, value: valueExpression };
+      if (!omitAttributeValues) this.attributeValues[valueExpression] = value;
+      return {
+        key: keyExpression,
+        value: valueExpression
+      };
     }
   }
   build() {
-    var _a;
+    var _a2;
     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;
+      (_a2 = this.filters) == null ? void 0 : _a2.forEach((filter, index) => {
+        var _a3, _b;
         if (filter == null ? void 0 : filter.logicOperator) {
-          if ((_a2 = filter == null ? void 0 : filter.config) == null ? void 0 : _a2.openExpression) {
+          if ((_a3 = filter == null ? void 0 : filter.config) == null ? void 0 : _a3.openExpression) {
             filterExpression = filterExpression.replace(/\s+(AND|OR)\s*$/, ` ${filter.config.parentKey} (`);
             if (filterExpression === "") filterExpression += "(";
             filterExpression += `${filter.expression} ${filter.logicOperator} `;
@@ -493,16 +574,19 @@ var QueryBuilderConditionService = class {
       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;
+    if (Object.values(this.attributeNames).length > 0) this.command["ExpressionAttributeNames"] = this.attributeNames;
+    if (Object.values(this.attributeValues).length > 0) this.command["ExpressionAttributeValues"] = this.attributeValues;
   }
 };
+__name(_QueryBuilderConditionService, "QueryBuilderConditionService");
+var QueryBuilderConditionService = _QueryBuilderConditionService;
 
 // src/services/cruds/dynamodb/queryBuilder.service.ts
-var QueryBuilderService = class {
+var _QueryBuilderService = class _QueryBuilderService {
   constructor(useScan = false) {
+    __publicField(this, "useScan");
+    __publicField(this, "command");
+    __publicField(this, "condition");
     this.useScan = useScan;
     this.command = {};
     this.condition = new QueryBuilderConditionService(this);
@@ -543,16 +627,16 @@ var QueryBuilderService = class {
     return this;
   }
   where(keyName) {
-    this.condition.setKey(keyName).setTmpLogicOp(null).from("where" /* where */);
+    this.condition.setKey(keyName).setTmpLogicOp(null).from(METHOD_TO_QUERY.where);
     return this.condition;
   }
   filter(keyName, logicOperator = "AND", config) {
-    this.condition.setKey(keyName).setTmpLogicOp(logicOperator).setConfig(config).from("filter" /* filter */);
+    this.condition.setKey(keyName).setTmpLogicOp(logicOperator).setConfig(config).from(METHOD_TO_QUERY.filter);
     return this.condition;
   }
   update(attribute) {
     for (const [key, value] of Object.entries(attribute)) {
-      this.condition.setKey(key).from("update" /* update */);
+      this.condition.setKey(key).from(METHOD_TO_QUERY.update);
       this.condition.eq(value);
     }
     return this;
@@ -562,47 +646,53 @@ var QueryBuilderService = class {
     return this;
   }
   count() {
-    this.command.Select = "COUNT" /* COUNT */;
+    this.command.Select = AGGREGATE_FUNCTIONS.COUNT;
     return this;
   }
 };
+__name(_QueryBuilderService, "QueryBuilderService");
+var QueryBuilderService = _QueryBuilderService;
 
 // src/helpers/tableHelper.ts
 function getTableColumnNames(columns) {
   return Object.keys(columns);
 }
+__name(getTableColumnNames, "getTableColumnNames");
 function findIdColumnName(columns) {
-  return getTableColumnNames(columns).find(
-    (columnName) => columns[columnName].columnId === true
-  );
+  return getTableColumnNames(columns).find((columnName) => columns[columnName].columnId === true);
 }
+__name(findIdColumnName, "findIdColumnName");
 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;
 }
+__name(getTableName, "getTableName");
 function getPrimaryKeyColumns(columns) {
-  return getTableColumnNames(columns).filter(
-    (columnName) => columns[columnName].primary === true
-  );
+  return getTableColumnNames(columns).filter((columnName) => columns[columnName].primary === true);
 }
+__name(getPrimaryKeyColumns, "getPrimaryKeyColumns");
 
 // src/error/NoRecordsAffectedException.ts
-var NoRecordsAffectedException = class extends Error {
+var _NoRecordsAffectedException = class _NoRecordsAffectedException extends Error {
   constructor() {
     super("No records affected by update");
     this.name = "NoRecordsAffectedException";
   }
 };
+__name(_NoRecordsAffectedException, "NoRecordsAffectedException");
+var NoRecordsAffectedException = _NoRecordsAffectedException;
 
 // src/helpers/errorHelper.ts
 function logError(context, err) {
   const message = err instanceof Error ? err.message : String(err);
   const stack = err instanceof Error ? err.stack : void 0;
-  console.error(`[data-persistence] ${context}:`, message);
+  const serviceName = process.env.SERVICE_NAME ? `[${process.env.SERVICE_NAME}/data-persistence]` : "[data-persistence]";
+  console.error(`${serviceName} ${context}:`, message);
   if (stack) console.error(stack);
 }
+__name(logError, "logError");
 function PersistenceErrorWrapper(queryResult) {
   const dynamoNoRecordsAffectedExceptions = [
     "ConditionalCheckFailedException"
@@ -620,13 +710,16 @@ function PersistenceErrorWrapper(queryResult) {
   }
   return queryResult;
 }
+__name(PersistenceErrorWrapper, "PersistenceErrorWrapper");
 
 // src/services/cruds/dynamodb/dynamoDbCrud.service.ts
 var _DynamoDbCrudService_instances, prepareAndExecuteUpdateExpression_fn, buildUpdateExpressionQuery_fn, getKeyObjectForUpdateExpression_fn, getUpdateExpressionOptions_fn, extractUpdateExpressionAttributesAndNames_fn;
-var DynamoDbCrudService = class {
+var _DynamoDbCrudService = class _DynamoDbCrudService {
   constructor(tableSchema) {
-    this.tableSchema = tableSchema;
     __privateAdd(this, _DynamoDbCrudService_instances);
+    __publicField(this, "tableSchema");
+    __publicField(this, "dynamoDbClientService");
+    this.tableSchema = tableSchema;
     this.dynamoDbClientService = new DynamoDbClientService(this.tableName);
   }
   get tableName() {
@@ -639,11 +732,11 @@ var DynamoDbCrudService = class {
     return getPrimaryKeyColumns(this.tableSchema.columns);
   }
   async create(data) {
-    var _a;
+    var _a2;
     if (Array.isArray(data)) {
       const response = await this.dynamoDbClientService.batchWrittenPut(data);
       return {
-        unprocessedItems: (_a = response.UnprocessedItems) != null ? _a : []
+        unprocessedItems: (_a2 = response.UnprocessedItems) != null ? _a2 : []
       };
     } else {
       await this.dynamoDbClientService.put(data);
@@ -655,28 +748,20 @@ var DynamoDbCrudService = class {
     throw new Error("Method not implemented.");
   }
   find(options = {}) {
-    var _a, _b, _c, _d;
+    var _a2, _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);
+    if ((_a2 = options.index) == null ? void 0 : _a2.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.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;
+    if (options.aggregateFunction === AGGREGATE_FUNCTIONS.COUNT) query.count();
+    return this.fetchResults(query.get(), (_d = options.pagination) == null ? void 0 : _d.limit, options.useScan).then((res) => {
+      var _a3, _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;
+      if ((_a3 = options.pagination) == null ? void 0 : _a3.limit) pagination.limit = (_b2 = options.pagination) == null ? void 0 : _b2.limit;
       return {
         items: res.items,
         pagination,
@@ -685,24 +770,18 @@ var DynamoDbCrudService = class {
     });
   }
   async fetchResults(command, limit = 100, useScan = false) {
-    var _a, _b;
+    var _a2, _b;
     let results = [];
     let lastEvaluatedKey = {};
     let rowsCount = 0;
     do {
-      const result = await this.fetchBatch(
-        command,
-        useScan,
-        lastEvaluatedKey
-      );
-      const rows = (_a = result.Items) != null ? _a : [];
+      const result = await this.fetchBatch(command, useScan, lastEvaluatedKey);
+      const rows = (_a2 = result.Items) != null ? _a2 : [];
       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;
+    const encryptedLastEvaluatedKey = this.isNotEmptyObject(lastEvaluatedKey) ? this.encryptPaginationKey(lastEvaluatedKey) : null;
     return {
       items: results,
       lastEvaluatedKey: encryptedLastEvaluatedKey,
@@ -710,26 +789,25 @@ var DynamoDbCrudService = class {
     };
   }
   async fetchBatch(command, useScan, lastEvaluatedKey) {
-    var _a, _b, _c;
-    if (this.isNotEmptyObject(lastEvaluatedKey))
-      command.ExclusiveStartKey = lastEvaluatedKey;
+    var _a2, _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);
+    if (command.Select !== AGGREGATE_FUNCTIONS.COUNT) {
+      command.Limit = ((_a2 = command.Limit) != null ? _a2 : 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));
+    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);
+    if (pagination == null ? void 0 : pagination.from) await this.findAll(__spreadProps(__spreadValues({}, options), {
+      pagination
+    }), allResults);
     return {
       items: allResults,
       pagination: null,
@@ -737,20 +815,20 @@ var DynamoDbCrudService = class {
     };
   }
   async findCount(options = {}) {
-    var _a;
+    var _a2;
     const findOptions = __spreadProps(__spreadValues({}, options), {
-      aggregateFunction: "COUNT" /* COUNT */
+      aggregateFunction: AGGREGATE_FUNCTIONS.COUNT
     });
-    if ((_a = options.pagination) == null ? void 0 : _a.from) {
+    if ((_a2 = options.pagination) == null ? void 0 : _a2.from) {
       return this.find(findOptions).then((res) => res.count);
     } else {
       return this.findAll(findOptions).then((res) => res.count);
     }
   }
   buildFindItemQuery(options) {
-    var _a;
+    var _a2;
     const query = new QueryBuilderService();
-    if ((_a = options.index) == null ? void 0 : _a.indexName) query.usingIndex(options.index.indexName);
+    if ((_a2 = options.index) == null ? void 0 : _a2.indexName) query.usingIndex(options.index.indexName);
     this.applyFilters(query, options);
     query.projection(options.fields);
     query.limit(1);
@@ -759,20 +837,20 @@ var DynamoDbCrudService = class {
   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];
+      var _a2;
+      if ((_a2 = result.Items) == null ? void 0 : _a2.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];
+    var _a2, _b;
+    const operator = FILTER_OPERATOR_MAP[(_b = (_a2 = filter.operator) == null ? void 0 : _a2.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];
+    var _a2, _b;
+    const operator = FILTER_OPERATOR_MAP[(_b = (_a2 = filter.operator) == null ? void 0 : _a2.toUpperCase()) != null ? _b : DYNAMODB_OPERATORS.EQUAL];
     query.filter(filter.attribute, logicOperator, config)[operator](filter.value);
   }
   applyFilters(query, options) {
@@ -783,8 +861,8 @@ var DynamoDbCrudService = class {
     }
   }
   applySimpleFilters(query, options) {
-    var _a, _b;
-    const queryIndexColumns = (_b = (_a = options.index) == null ? void 0 : _a.columns) != null ? _b : [];
+    var _a2, _b;
+    const queryIndexColumns = (_b = (_a2 = options.index) == null ? void 0 : _a2.columns) != null ? _b : [];
     const defaultWhereProperties = this.defaultPrimaryKeys;
     const whereProperties = (queryIndexColumns == null ? void 0 : queryIndexColumns.length) ? queryIndexColumns : defaultWhereProperties;
     const filters = options.filters;
@@ -798,42 +876,33 @@ var DynamoDbCrudService = class {
     this.buildFilterExpression(query, options);
   }
   buildFilterExpression(query, options, parentKey) {
-    var _a;
+    var _a2;
     const compositeFilters = options.filters;
-    const queryIndexColumns = ((_a = options.index) == null ? void 0 : _a.columns) || [];
+    const queryIndexColumns = ((_a2 = options.index) == null ? void 0 : _a2.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
-            );
+      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) {
@@ -871,7 +940,11 @@ var DynamoDbCrudService = class {
   async upsert(keyColumnNames, data) {
     const filters = [];
     keyColumnNames.map((key) => {
-      filters.push({ attribute: key, value: data[key], operator: "EQUAL" });
+      filters.push({
+        attribute: key,
+        value: data[key],
+        operator: "EQUAL"
+      });
     });
     const savedRecord = await this.findItem({
       filters
@@ -882,9 +955,7 @@ var DynamoDbCrudService = class {
   }
   async remove(filters, options) {
     if (options == null ? void 0 : options.filterGroups) {
-      await this.dynamoDbClientService.batchRemove(
-        filters
-      );
+      await this.dynamoDbClientService.batchRemove(filters);
     } else {
       const key = filters.reduce((obj, item) => {
         const property = item.attribute;
@@ -907,8 +978,10 @@ var DynamoDbCrudService = class {
   }
 };
 _DynamoDbCrudService_instances = new WeakSet();
-prepareAndExecuteUpdateExpression_fn = async function(filters, actions, options) {
-  const queryObject = __privateMethod(this, _DynamoDbCrudService_instances, buildUpdateExpressionQuery_fn).call(this, { filters }).get();
+prepareAndExecuteUpdateExpression_fn = /* @__PURE__ */ __name(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 = [];
@@ -926,46 +999,38 @@ prepareAndExecuteUpdateExpression_fn = async function(filters, actions, options)
   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;
+  if (queryObject.FilterExpression) dbParams["ConditionExpression"] = queryObject.FilterExpression;
+  return this.dynamoDbClientService.updateExpressions(keyObject, dbParams);
+}, "#prepareAndExecuteUpdateExpression");
+buildUpdateExpressionQuery_fn = /* @__PURE__ */ __name(function(options) {
+  var _a2;
   const query = new QueryBuilderService();
-  if ((_a = options.index) == null ? void 0 : _a.indexName) query.usingIndex(options.index.indexName);
+  if ((_a2 = options.index) == null ? void 0 : _a2.indexName) query.usingIndex(options.index.indexName);
   this.applyFilters(query, options);
   return query;
-};
-getKeyObjectForUpdateExpression_fn = function(queryObject, primaryKeys) {
+}, "#buildUpdateExpressionQuery");
+getKeyObjectForUpdateExpression_fn = /* @__PURE__ */ __name(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];
-      }
+  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) {
+}, "#getKeyObjectForUpdateExpression");
+getUpdateExpressionOptions_fn = /* @__PURE__ */ __name(function(options) {
   const updateExprOptions = {
     ReturnValues: options.returnValues
   };
-  if (options.expressionAttributeNames)
-    updateExprOptions.ExpressionAttributeNames = options.expressionAttributeNames;
-  if (options.expressionAttributeValues)
-    updateExprOptions.ExpressionAttributeValues = options.expressionAttributeValues;
+  if (options.expressionAttributeNames) updateExprOptions.ExpressionAttributeNames = options.expressionAttributeNames;
+  if (options.expressionAttributeValues) updateExprOptions.ExpressionAttributeValues = options.expressionAttributeValues;
   return updateExprOptions;
-};
-extractUpdateExpressionAttributesAndNames_fn = function(actions, actionType) {
+}, "#getUpdateExpressionOptions");
+extractUpdateExpressionAttributesAndNames_fn = /* @__PURE__ */ __name(function(actions, actionType) {
   const actionUpdateExpressions = [];
   actions[actionType].forEach((action) => {
     switch (actionType) {
@@ -977,47 +1042,39 @@ extractUpdateExpressionAttributesAndNames_fn = function(actions, actionType) {
       case DYNAMO_DB_UPDATE_ACTIONS.SET:
         {
           let operator = "";
-          if (actionType == DYNAMO_DB_UPDATE_ACTIONS.SET)
-            operator = "=";
-          actionUpdateExpressions.push(
-            `${action.path} ${operator}${action.value}`
-          );
+          if (actionType == DYNAMO_DB_UPDATE_ACTIONS.SET) operator = "=";
+          actionUpdateExpressions.push(`${action.path} ${operator}${action.value}`);
         }
         break;
     }
   });
-  const actionUpdateExpression = `${actionType} ${actionUpdateExpressions.join(
-    ", "
-  )}`;
+  const actionUpdateExpression = `${actionType} ${actionUpdateExpressions.join(", ")}`;
   return actionUpdateExpression;
-};
+}, "#extractUpdateExpressionAttributesAndNames");
+__name(_DynamoDbCrudService, "DynamoDbCrudService");
+var DynamoDbCrudService = _DynamoDbCrudService;
 
 // src/services/connectionRegistry.ts
 var poolRegistry = /* @__PURE__ */ new Set();
 var clientRegistry = /* @__PURE__ */ new Set();
-var shutdownHandlersRegistered = false;
-function registerShutdownHandlers() {
-  if (shutdownHandlersRegistered) return;
-  shutdownHandlersRegistered = true;
-  const handler = async (signal) => {
-    const poolCount = poolRegistry.size;
-    const clientCount = clientRegistry.size;
-    console.log(
-      `[data-persistence] ${signal} received, closing ${poolCount} pool(s) and ${clientCount} client(s)...`
-    );
-    try {
-      await closeAllPools();
-      await closeAllClients();
-      console.log("[data-persistence] All connections closed");
-    } catch (err) {
-      logError("Unexpected error during shutdown", err);
-    }
-  };
-  process.on("SIGTERM", () => void handler("SIGTERM"));
-  process.on("SIGINT", () => void handler("SIGINT"));
+async function shutdown(signal) {
+  const poolCount = poolRegistry.size;
+  const clientCount = clientRegistry.size;
+  let serviceName = process.env.SERVICE_NAME ? `[${process.env.SERVICE_NAME}/data-persistence]` : "[data-persistence]";
+  console.log(`${serviceName} ${signal} received, closing ${poolCount} pool(s) and ${clientCount} client(s)...`);
+  try {
+    await closeAllClients();
+    await closeAllPools();
+    console.log(`${serviceName} All connections closed`);
+  } catch (err) {
+    logError("Unexpected error during shutdown", err);
+  }
 }
+__name(shutdown, "shutdown");
 async function closeAllPools() {
-  const pools = [...poolRegistry];
+  const pools = [
+    ...poolRegistry
+  ];
   poolRegistry.clear();
   const results = await Promise.allSettled(pools.map((pool) => pool.end()));
   results.forEach((result, i) => {
@@ -1026,40 +1083,42 @@ async function closeAllPools() {
     }
   });
 }
+__name(closeAllPools, "closeAllPools");
 async function closeAllClients() {
-  const clients = [...clientRegistry];
+  const clients = [
+    ...clientRegistry
+  ];
   clientRegistry.clear();
-  const results = await Promise.allSettled(
-    clients.map((client) => client.end())
-  );
+  const results = await Promise.allSettled(clients.map((client) => client.end()));
   results.forEach((result, i) => {
     if (result.status === "rejected") {
       logError(`Client[${i}] failed to close`, result.reason);
     }
   });
 }
+__name(closeAllClients, "closeAllClients");
 function registerPool(pool) {
   if (!pool) return;
   try {
     poolRegistry.add(pool);
-    registerShutdownHandlers();
   } catch (err) {
     logError("Failed to register pool, closing pool", err);
     void pool.end().catch((e) => logError("pool.end failed during rollback", e));
     throw err;
   }
 }
+__name(registerPool, "registerPool");
 function registerClient(client) {
   if (!client) return;
   try {
     clientRegistry.add(client);
-    registerShutdownHandlers();
   } catch (err) {
     logError("Failed to register client, closing client", err);
     void client.end().catch((e) => logError("client.end failed during rollback", e));
     throw err;
   }
 }
+__name(registerClient, "registerClient");
 function unregisterClient(client) {
   try {
     clientRegistry.delete(client);
@@ -1067,15 +1126,14 @@ function unregisterClient(client) {
     logError("Failed to unregister client", err);
   }
 }
+__name(unregisterClient, "unregisterClient");
 
 // src/services/cruds/postgresql/connection.service.ts
-var ConnectionService = class {
+var _ConnectionService = class _ConnectionService {
   get connectionString() {
     const connectionString = process.env.MULTIPLATFORM_PG_CONNECTION_STRING || "";
     if (!connectionString) {
-      throw new Error(
-        "MULTIPLATFORM_PG_CONNECTION_STRING environment variable must be configured"
-      );
+      throw new Error("MULTIPLATFORM_PG_CONNECTION_STRING environment variable must be configured");
     }
     return connectionString;
   }
@@ -1097,18 +1155,24 @@ var ConnectionService = class {
     void client.end().catch((e) => logError("client.end failed during release", e));
   }
 };
+__name(_ConnectionService, "ConnectionService");
+var ConnectionService = _ConnectionService;
 
 // src/services/cruds/postgresql/query.service.ts
-var QueryService = class {
+var _QueryService = class _QueryService {
   constructor(pool) {
+    __publicField(this, "pool");
+    __publicField(this, "connectionService");
     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);
+      if (process.env.NODE_ENV === "development") {
+        const serviceName = process.env.SERVICE_NAME ? `[${process.env.SERVICE_NAME}/data-persistence]` : "[data-persistence]";
+        console.info(`${serviceName} Query as Text:`, queryText);
+      }
       const result = await client.query(queryText, values);
       return result;
     } finally {
@@ -1120,14 +1184,17 @@ var QueryService = class {
     }
   }
 };
+__name(_QueryService, "QueryService");
+var QueryService = _QueryService;
 
 // src/services/cruds/postgresql/postgreSqlClient.service.ts
-var PostgresqlClientService = class extends QueryService {
+var _PostgresqlClientService = class _PostgresqlClientService extends QueryService {
   constructor(tableSchema, poolClient) {
     super(poolClient);
-    this.isCompositeFilter = function(value) {
+    __publicField(this, "crudSchema");
+    __publicField(this, "isCompositeFilter", /* @__PURE__ */ __name(function(value) {
       return "OR" in value || "AND" in value;
-    };
+    }, "isCompositeFilter"));
     this.crudSchema = tableSchema;
   }
   get dbSchema() {
@@ -1137,29 +1204,28 @@ var PostgresqlClientService = class extends QueryService {
     return getTableName(this.crudSchema.table, "alias") || getTableName(this.crudSchema.table);
   }
   get isTemporalTable() {
-    var _a;
-    return (_a = this.crudSchema) == null ? void 0 : _a.isTemporalTable;
+    var _a2;
+    return (_a2 = this.crudSchema) == null ? void 0 : _a2.isTemporalTable;
   }
   getWildcardValue(operator, value) {
-    if (operator === "CONTAINS" /* CONTAINS */ || operator === "NOT_CONTAINS" /* NOT_CONTAINS */) {
+    if (operator === FilterOperator.CONTAINS || operator === FilterOperator.NOT_CONTAINS) {
       return "%" + value + "%";
-    } else if (operator === "STARTS_WITH" /* STARTS_WITH */) {
+    } else if (operator === FilterOperator.STARTS_WITH) {
       return value + "%";
     } else {
       return value;
     }
   }
   buildClause(operator, attribute, relativePath, value) {
-    var _a;
+    var _a2;
     const formattedValue = literal(value);
-    operator = operator ? operator.toUpperCase() : "EQUAL" /* EQUAL */;
+    operator = operator ? operator.toUpperCase() : FilterOperator.EQUAL;
     const postgresOperator = POSTGRES_FILTER_OPERATOR_MAP[operator];
-    if (!postgresOperator)
-      throw new Error(`Unsupported filter operator: ${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);
+    const columnType = columnExists && ((_a2 = this.crudSchema.columns[attribute]) == null ? void 0 : _a2.type);
     if (relativePath != void 0) {
       const attributePath = relativePath.split(".").join(",");
       property = `("${attribute}" #> '{${attributePath}}')`;
@@ -1170,27 +1236,25 @@ var PostgresqlClientService = class extends QueryService {
     } 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 === FilterOperator.IN) {
+      const formattedValues = Array.isArray(value) ? value.map(literal) : [
+        formattedValue
+      ];
+      return `${property} ${postgresOperator} (${formattedValues.join(", ")})`;
     }
-    if (operator === "BETWEEN" /* BETWEEN */) {
+    if (operator === FilterOperator.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 === FilterOperator.NOT_EQUAL && value !== null) {
+      return `(${property} ${postgresOperator} ${literal(value)} OR ${property} IS NULL)`;
     }
-    if (operator === "NOT_EXIST" /* NOT_EXIST */ || operator === "EXIST" /* EXIST */) {
+    if (operator === FilterOperator.NOT_EXIST || operator === FilterOperator.EXIST) {
       return `${property} ${postgresOperator}`;
     }
-    if ((operator === "CONTAINS" /* CONTAINS */ || operator === "NOT_CONTAINS" /* NOT_CONTAINS */) && columnType === "array") {
+    if ((operator === FilterOperator.CONTAINS || operator === FilterOperator.NOT_CONTAINS) && columnType === "array") {
       const filterValue = typeof value === "number" ? value : `'${value}'`;
       let filterString = `${filterValue} = ANY(${property})`;
-      if (operator === "NOT_CONTAINS" /* NOT_CONTAINS */) {
+      if (operator === FilterOperator.NOT_CONTAINS) {
         if (value === null) {
           filterString = `(NOT (${filterString}))`;
         } else {
@@ -1205,16 +1269,9 @@ var PostgresqlClientService = class extends QueryService {
   buildFilterClause(filters, logicOperator) {
     if (Array.isArray(filters)) {
       const filterClauses = filters.map((filter) => {
-        return this.buildClause(
-          filter.operator,
-          filter.attribute,
-          filter.relativePath,
-          filter.value
-        );
+        return this.buildClause(filter.operator, filter.attribute, filter.relativePath, filter.value);
       });
-      return filterClauses.join(
-        ` ${logicOperator != null ? logicOperator : "AND" /* AND */} `
-      );
+      return filterClauses.join(` ${logicOperator != null ? logicOperator : FILTER_LOGIC_OPERATORS.AND} `);
     } else {
       return this.buildQueryByClause(filters);
     }
@@ -1228,24 +1285,15 @@ var PostgresqlClientService = class extends QueryService {
       }
       if (this.isCompositeFilter(value)) {
         filterClauses += "(";
-        filterClauses += this.buildQueryByClause(
-          value
-        );
+        filterClauses += this.buildQueryByClause(value);
         filterClauses += ")";
       } else {
         value.forEach((filter) => {
           let clause = "";
           if (this.isCompositeFilter(filter)) {
-            clause = `(${this.buildQueryByClause(
-              filter
-            )})`;
+            clause = `(${this.buildQueryByClause(filter)})`;
           } else {
-            clause = this.buildClause(
-              filter.operator,
-              filter.attribute,
-              filter.relativePath,
-              filter.value
-            );
+            clause = this.buildClause(filter.operator, filter.attribute, filter.relativePath, filter.value);
           }
           filterClauses += `${clause} ${key} `;
         });
@@ -1256,7 +1304,7 @@ var PostgresqlClientService = class extends QueryService {
     return filterClauses;
   }
   formatOrderByItem(sort) {
-    return `${ident(sort.column)} ${sort.direction || "ASC" /* ASC */}`;
+    return `${ident(sort.column)} ${sort.direction || SORT_DIRECTIONS.ASC}`;
   }
   buildOrderByClause(querySorting) {
     try {
@@ -1287,16 +1335,8 @@ var PostgresqlClientService = class extends QueryService {
   }
   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
-    );
+    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) {
@@ -1313,8 +1353,7 @@ var PostgresqlClientService = class extends QueryService {
   }
   addFiltersToQuery(query, filters) {
     if (!filters) return query;
-    if (this.isValidFiltersInput(filters))
-      query += ` WHERE ${this.buildFilterClause(filters)}`;
+    if (this.isValidFiltersInput(filters)) query += ` WHERE ${this.buildFilterClause(filters)}`;
     return query;
   }
   addOrderByToQuery(query, orderBy) {
@@ -1330,17 +1369,12 @@ var PostgresqlClientService = class extends QueryService {
     return query;
   }
   getSelectClause(aggregateFunction, fields = []) {
-    if (aggregateFunction)
-      return `CAST(${aggregateFunction}(1) AS INTEGER) AS "${buildAggFunctionAlias(
-        aggregateFunction
-      )}"`;
+    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 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}"`);
@@ -1367,10 +1401,7 @@ var PostgresqlClientService = class extends QueryService {
   }
   async findCommand(options = {}) {
     const rawWithClause = this.getRawWithClause(options.rawWith);
-    let query = `SELECT ${this.getSelectClause(
-      options.aggregateFunction,
-      options.fields
-    )} FROM ${this.getQueryFrom()}`;
+    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);
@@ -1399,9 +1430,7 @@ var PostgresqlClientService = class extends QueryService {
     }
   }
   async updateCommand(filters, data) {
-    let query = `UPDATE ${ident(this.dbSchema)}.${ident(
-      this.tableName
-    )} SET`;
+    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}`;
@@ -1416,13 +1445,12 @@ var PostgresqlClientService = class extends QueryService {
       const dbValue = literal(this.formatValue(value));
       return `${ident(key)} = ${dbValue}`;
     }) || [];
-    if (!(updateClauses == null ? void 0 : updateClauses.length))
-      return this.createCommand([data]);
+    if (!(updateClauses == null ? void 0 : updateClauses.length)) return this.createCommand([
+      data
+    ]);
     const columnNames = Object.keys(data);
     const values = columnNames.map((key) => this.formatValue(data[key]));
-    let query = format(`INSERT INTO ${ident(this.dbSchema)}.${ident(
-      this.tableName
-    )} (%I) VALUES (%L) ON CONFLICT (%I) DO UPDATE SET`, columnNames, values, keyColumnNames);
+    let query = format(`INSERT INTO ${ident(this.dbSchema)}.${ident(this.tableName)} (%I) VALUES (%L) ON CONFLICT (%I) DO UPDATE SET`, columnNames, values, keyColumnNames);
     query += ` ${updateClauses.join(", ")} RETURNING *;`;
     return this.runQuery(query);
   }
@@ -1433,19 +1461,13 @@ var PostgresqlClientService = class extends QueryService {
     return filterClauses.join(" OR ");
   }
   async deleteCommand(filters, useFilterGroups = false) {
-    let query = `DELETE FROM ${ident(this.dbSchema)}.${ident(
-      this.tableName
-    )}`;
+    let query = `DELETE FROM ${ident(this.dbSchema)}.${ident(this.tableName)}`;
     if (filters) {
       query += " WHERE ";
       if (useFilterGroups) {
-        query += this.buildFilterClauseForFilterGroups(
-          filters
-        );
+        query += this.buildFilterClauseForFilterGroups(filters);
       } else {
-        query += this.buildFilterClause(
-          filters
-        );
+        query += this.buildFilterClause(filters);
       }
     }
     return this.runQuery(query);
@@ -1454,24 +1476,12 @@ var PostgresqlClientService = class extends QueryService {
     return this.runQuery(queryText, values);
   }
   async updateExpressionCommand(filters, actions, options = {}) {
-    let query = `UPDATE ${ident(this.dbSchema)}.${ident(
-      this.tableName
-    )} SET`;
+    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 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 = {};
@@ -1479,20 +1489,22 @@ var PostgresqlClientService = class extends QueryService {
     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(
+        queryFunctions.push({
           path,
           value,
-          {
-            createNewColumn,
-            actionName
-          }
-        );
+          dynamoFuncName
+        });
+      }
+      if (path.includes(".") && !dynamoFuncName) {
+        const jsonExpr = this.getJSONBSetExpressionByAction(path, value, {
+          createNewColumn,
+          actionName
+        });
         const columnName = jsonExpr.columnName;
         if (!jsonSetExpressionGroup[columnName]) {
-          jsonSetExpressionGroup[columnName] = [jsonExpr];
+          jsonSetExpressionGroup[columnName] = [
+            jsonExpr
+          ];
         } else {
           jsonSetExpressionGroup[columnName].push(jsonExpr);
         }
@@ -1506,16 +1518,13 @@ var PostgresqlClientService = class extends QueryService {
           setObjProperty = true;
           columnName = "qvAttributes";
           column = this.crudSchema.columns[columnName];
-          if ((column == null ? void 0 : column.type) == void 0)
-            throw `Column type definition for column: (${path}) must be in the CrudSchema`;
+          if ((column == null ? void 0 : column.type) == void 0) throw `Column type definition for column: (${path}) must be in the CrudSchema`;
           columnType = Array.isArray(value) ? "array" : typeof value == "object" ? "object" : "default";
         }
         switch (columnType) {
           case "object":
             {
-              const valueSerialized = `${JSON.stringify(
-                value
-              ).replace(/'/g, "''")}`;
+              const valueSerialized = `${JSON.stringify(value).replace(/'/g, "''")}`;
               expValue = `'${valueSerialized}'::jsonb`;
             }
             break;
@@ -1532,23 +1541,14 @@ var PostgresqlClientService = class extends QueryService {
         updateClauses.push(`${ident(columnName)} = ${expValue}`);
       }
     });
-    this.setCommonColumnsQueryFunctions(
-      jsonSetExpressionGroup,
-      queryFunctions
-    );
+    this.setCommonColumnsQueryFunctions(jsonSetExpressionGroup, queryFunctions);
     if (Object.keys(jsonSetExpressionGroup).length > 0) {
       Object.keys(jsonSetExpressionGroup).forEach((groupIndex) => {
-        const jsonSetExpression = this.buildJSONBExpression(
-          jsonSetExpressionGroup[groupIndex],
-          "jsonb_set"
-        );
+        const jsonSetExpression = this.buildJSONBExpression(jsonSetExpressionGroup[groupIndex], "jsonb_set");
         updateClauses.push(`${groupIndex} = ${jsonSetExpression}`);
       });
     }
-    this.buildUpdateClausesFormDynamoFunctions(
-      queryFunctions,
-      updateClauses
-    );
+    this.buildUpdateClausesFormDynamoFunctions(queryFunctions, updateClauses);
     query += ` ${updateClauses.join(", ")}`;
     query += " WHERE ";
     query += this.buildFilterClause(filters);
@@ -1558,17 +1558,10 @@ var PostgresqlClientService = class extends QueryService {
     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}`
-          );
+          const jsonExpr = this.buildJSONBExpression(queryFunction.value.jsonExpression, "jsonb_insert");
+          updateClauses.push(`${ident(queryFunction.path)} = ${jsonExpr}`);
         } else {
-          updateClauses.push(
-            `${ident(queryFunction.path)} = ${queryFunction.value}`
-          );
+          updateClauses.push(`${ident(queryFunction.path)} = ${queryFunction.value}`);
         }
       });
     }
@@ -1626,10 +1619,7 @@ var PostgresqlClientService = class extends QueryService {
     const parentPath = pathSplitted[0];
     const { createNewColumn, actionName } = options;
     const pathSerialized = pathSplitted.slice(1).join(",");
-    const valueSerialized = `'${JSON.stringify(value).replace(
-      /'/g,
-      "''"
-    )}'`;
+    const valueSerialized = `'${JSON.stringify(value).replace(/'/g, "''")}'`;
     if (actionName == DYNAMO_DB_UPDATE_ACTIONS.ADD) {
       if (typeof value != "string" && !isNaN(value)) {
         const resultExpr = {
@@ -1657,7 +1647,9 @@ var PostgresqlClientService = class extends QueryService {
         value: attributesFromGroup.slice(1).join(",").trim(),
         isDynamoFunction: true,
         functionExpr: "",
-        jsonExpression: [{}]
+        jsonExpression: [
+          {}
+        ]
       };
       if (columnType == "array") {
         attributes["functionExpr"] = this.buildArrayAppendExpr(attributes);
@@ -1680,11 +1672,7 @@ var PostgresqlClientService = class extends QueryService {
       isDynamoFunction: params == null ? void 0 : params.isDynamoFunction,
       relativePath: arrayPath.length && Array.isArray(arrayPath) ? arrayPath : []
     };
-    const jsonbInsertExpressions = this.getExpressionsByDefinitionForJSONBInsert(
-      columnName,
-      params.value,
-      options
-    );
+    const jsonbInsertExpressions = this.getExpressionsByDefinitionForJSONBInsert(columnName, params.value, options);
     return jsonbInsertExpressions;
   }
   getExpressionsByDefinitionForJSONBInsert(columnName, value, options) {
@@ -1700,18 +1688,14 @@ var PostgresqlClientService = class extends QueryService {
         parsedValue.forEach((arrayValue) => {
           arrayValue = typeof arrayValue == "string" ? `"${arrayValue}"` : arrayValue;
           jsonbInsertExpressions.push({
-            jsonExpr: `'{${pathToAffect}}','${this.serializeJSONValue(
-              arrayValue
-            )}'`,
+            jsonExpr: `'{${pathToAffect}}','${this.serializeJSONValue(arrayValue)}'`,
             columnName: `"${columnName}"`,
             functionName: "jsonb_insert"
           });
         });
       } else {
         jsonbInsertExpressions.push({
-          jsonExpr: `'{${pathToAffect}}','${this.serializeJSONValue(
-            parsedValue
-          )}'`,
+          jsonExpr: `'{${pathToAffect}}','${this.serializeJSONValue(parsedValue)}'`,
           columnName: `"${columnName}"`,
           functionName: "jsonb_insert"
         });
@@ -1726,15 +1710,9 @@ var PostgresqlClientService = class extends QueryService {
     return jsonbInsertExpressions;
   }
   getInsertExprFromJsonbDef(queryValue, columnType) {
-    const listAppendParams = this.getListAppendDefFromValue(
-      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
-      );
+      queryValue = queryValue.replace(listAppendParams.originalString, listAppendParams.functionExpr);
     } else {
       return listAppendParams;
     }
@@ -1742,27 +1720,15 @@ var PostgresqlClientService = class extends QueryService {
   }
   replacePathAndValueByAttributeNames(actions, options, columns, actionName) {
     return actions.map((action) => {
-      action.path = this.replaceExpressionAttributeNames(
-        action.path,
-        options
-      );
+      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.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.value = this.replaceExpressionAttributeValues(action.value, options);
       }
       action.actionName = actionName;
       action.createNewColumn = true;
@@ -1775,17 +1741,12 @@ var PostgresqlClientService = class extends QueryService {
     const exprAttributeValuesKeys = expressionAttributeValues ? Object.keys(expressionAttributeValues) : [];
     if (exprAttributeNamesKeys.length > 0) {
       exprAttributeNamesKeys.forEach((exprAttribute) => {
-        value = value.replace(
-          exprAttribute,
-          expressionAttributeNames[exprAttribute]
-        );
+        value = value.replace(exprAttribute, expressionAttributeNames[exprAttribute]);
       });
     }
     if (exprAttributeValuesKeys.length > 0) {
       exprAttributeValuesKeys.forEach((exprAttribute) => {
-        const valueSerialized = this.serializeJSONValue(
-          expressionAttributeValues[exprAttribute]
-        );
+        const valueSerialized = this.serializeJSONValue(expressionAttributeValues[exprAttribute]);
         value = value.replace(exprAttribute, `${valueSerialized}`);
       });
     }
@@ -1794,12 +1755,10 @@ var PostgresqlClientService = class extends QueryService {
   replaceExpressionAttributeNames(path, options) {
     const { expressionAttributeNames } = options;
     if (expressionAttributeNames) {
-      Object.keys(expressionAttributeNames).forEach(
-        (attributeName) => {
-          const attributeNameValue = expressionAttributeNames[attributeName];
-          path = path.replace(attributeName, attributeNameValue);
-        }
-      );
+      Object.keys(expressionAttributeNames).forEach((attributeName) => {
+        const attributeNameValue = expressionAttributeNames[attributeName];
+        path = path.replace(attributeName, attributeNameValue);
+      });
     }
     return path;
   }
@@ -1822,24 +1781,27 @@ var PostgresqlClientService = class extends QueryService {
     }
   }
 };
+__name(_PostgresqlClientService, "PostgresqlClientService");
+var PostgresqlClientService = _PostgresqlClientService;
 
 // src/services/cruds/postgresql/postgreSqlCrud.service.ts
-var PostgreSqlCrudService = class extends PostgresqlClientService {
+var _PostgreSqlCrudService = class _PostgreSqlCrudService extends PostgresqlClientService {
   constructor(tableSchema, poolClient) {
     super(tableSchema, poolClient);
+    __publicField(this, "tableSchema");
     this.tableSchema = tableSchema;
   }
   get idColumnName() {
     return findIdColumnName(this.tableSchema.columns);
   }
   normalizeInputData(inputData) {
-    var _a;
+    var _a2;
     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") {
+      } else if (Array.isArray(inputData[key]) && ((_a2 = this.tableSchema.columns[key]) == null ? void 0 : _a2.type) !== "array") {
         inputData[key] = JSON.stringify(inputData[key]);
       }
     }
@@ -1875,9 +1837,9 @@ var PostgreSqlCrudService = class extends PostgresqlClientService {
       });
     } else {
       const inputData = this.prepareData(data);
-      return this.createCommand([inputData]).then(
-        (result) => result.rowCount ? this.getItem(result.rows[0]) : null
-      );
+      return this.createCommand([
+        inputData
+      ]).then((result) => result.rowCount ? this.getItem(result.rows[0]) : null);
     }
   }
   findItem(findOptions) {
@@ -1887,15 +1849,16 @@ var PostgreSqlCrudService = class extends PostgresqlClientService {
   }
   async processQueryResult(findOptions, omitPagination = false) {
     const rows = await this.findCommand(findOptions);
-    const items = rows.map(
-      (row) => this.getItem(row)
-    );
+    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 },
+      pagination: omitPagination ? null : {
+        limit,
+        from: newFrom
+      },
       count: items.length
     };
     return result;
@@ -1908,16 +1871,16 @@ var PostgreSqlCrudService = class extends PostgresqlClientService {
   }
   async findCount(findOptions) {
     const items = await this.findCommand(__spreadProps(__spreadValues({}, findOptions), {
-      aggregateFunction: "COUNT" /* COUNT */
+      aggregateFunction: AGGREGATE_FUNCTIONS.COUNT
     }));
-    const aggFunctionProperty = buildAggFunctionAlias(
-      "COUNT" /* COUNT */
-    );
+    const aggFunctionProperty = buildAggFunctionAlias(AGGREGATE_FUNCTIONS.COUNT);
     const item = items.length ? items[0] : {};
     return item[aggFunctionProperty] || 0;
   }
   async update(filters, data, options = {}) {
-    const savedRecord = (options == null ? void 0 : options.skipFindItems) ? {} : await this.findItem({ filters });
+    const savedRecord = (options == null ? void 0 : options.skipFindItems) ? {} : await this.findItem({
+      filters
+    });
     const inputData = __spreadValues(__spreadValues({}, savedRecord), data);
     const result = await this.updateCommand(filters, this.prepareData(inputData));
     if (options == null ? void 0 : options.returnRowsAffected) {
@@ -1927,12 +1890,10 @@ var PostgreSqlCrudService = class extends PostgresqlClientService {
   }
   async upsert(keyColumnNames, data) {
     const inputData = this.prepareData(data);
-    return this.upsertCommand(keyColumnNames, inputData).then(
-      (result) => {
-        var _a;
-        return result.rowCount && ((_a = result.rows) == null ? void 0 : _a.length) ? this.getItem(result.rows[0]) : null;
-      }
-    );
+    return this.upsertCommand(keyColumnNames, inputData).then((result) => {
+      var _a2;
+      return result.rowCount && ((_a2 = result.rows) == null ? void 0 : _a2.length) ? this.getItem(result.rows[0]) : null;
+    });
   }
   async remove(filters, options) {
     await this.deleteCommand(filters, options == null ? void 0 : options.filterGroups);
@@ -1941,11 +1902,7 @@ var PostgreSqlCrudService = class extends PostgresqlClientService {
     return super.runQuery(querySentence, values);
   }
   async updateExpressions(filters, actions, options) {
-    const result = await this.updateExpressionCommand(
-      filters,
-      actions,
-      options
-    );
+    const result = await this.updateExpressionCommand(filters, actions, options);
     return PersistenceErrorWrapper(result);
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -1953,29 +1910,32 @@ var PostgreSqlCrudService = class extends PostgresqlClientService {
     return super.runQuery(query, params);
   }
 };
+__name(_PostgreSqlCrudService, "PostgreSqlCrudService");
+var PostgreSqlCrudService = _PostgreSqlCrudService;
 
 // src/services/crudFactory.service.ts
-var CrudFactory = class {
+var _CrudFactory = class _CrudFactory {
   static databaseClientService(crudSchema, pool) {
-    var _a;
-    const isMultiPlatformMode2 = ((_a = process.env.PLATFORM_TYPE) == null ? void 0 : _a.toLowerCase()) === "container";
-    if (isMultiPlatformMode2)
-      return new PostgreSqlCrudService(crudSchema, pool);
+    var _a2;
+    const isMultiPlatformMode2 = ((_a2 = process.env.PLATFORM_TYPE) == null ? void 0 : _a2.toLowerCase()) === "container";
+    if (isMultiPlatformMode2) return new PostgreSqlCrudService(crudSchema, pool);
     return new DynamoDbCrudService(crudSchema);
   }
 };
+__name(_CrudFactory, "CrudFactory");
+var CrudFactory = _CrudFactory;
 
 // src/services/crud.service.ts
-var CrudService = class {
+var _a;
+var CrudService = (_a = class {
   constructor(crudSchema, pool) {
+    __publicField(this, "pool");
+    __publicField(this, "crudSchema");
     this.pool = pool;
     this.crudSchema = crudSchema;
   }
   async getCrudServiceInstance() {
-    const crudService = await CrudFactory.databaseClientService(
-      this.crudSchema,
-      this.pool
-    );
+    const crudService = await CrudFactory.databaseClientService(this.crudSchema, this.pool);
     return crudService;
   }
   getDefaultValue(columnName) {
@@ -1996,45 +1956,29 @@ var CrudService = class {
   }
   create(data) {
     const processedData = Array.isArray(data) ? data.map(this.setDefaultValues.bind(this)) : this.setDefaultValues(data);
-    return this.getCrudServiceInstance().then(
-      (crudService) => crudService.create(processedData)
-    );
+    return this.getCrudServiceInstance().then((crudService) => crudService.create(processedData));
   }
   find(options) {
-    return this.getCrudServiceInstance().then(
-      (crudService) => crudService.find(options)
-    );
+    return this.getCrudServiceInstance().then((crudService) => crudService.find(options));
   }
   findItem(options) {
-    return this.getCrudServiceInstance().then(
-      (crudService) => crudService.findItem(options)
-    );
+    return this.getCrudServiceInstance().then((crudService) => crudService.findItem(options));
   }
   update(filters, data, options = {}) {
-    return this.getCrudServiceInstance().then(
-      (crudService) => crudService.update(filters, data, options)
-    );
+    return this.getCrudServiceInstance().then((crudService) => crudService.update(filters, data, options));
   }
   upsert(keyColumnNames, data) {
-    return this.getCrudServiceInstance().then(
-      (crudService) => crudService.upsert(keyColumnNames, data)
-    );
+    return this.getCrudServiceInstance().then((crudService) => crudService.upsert(keyColumnNames, data));
   }
   remove(filters, options = {}) {
-    return this.getCrudServiceInstance().then(
-      (crudService) => crudService.remove(filters, options)
-    );
+    return this.getCrudServiceInstance().then((crudService) => crudService.remove(filters, options));
   }
   findAll(options) {
-    const _a = options, { pagination } = _a, findAllOptions = __objRest(_a, ["pagination"]);
-    return this.getCrudServiceInstance().then(
-      (crudService) => crudService.findAll(findAllOptions)
-    );
+    const _a2 = options, { pagination } = _a2, findAllOptions = __objRest(_a2, ["pagination"]);
+    return this.getCrudServiceInstance().then((crudService) => crudService.findAll(findAllOptions));
   }
   findCount(findCountOptions) {
-    return this.getCrudServiceInstance().then(
-      (crudService) => crudService.findCount(findCountOptions)
-    );
+    return this.getCrudServiceInstance().then((crudService) => crudService.findCount(findCountOptions));
   }
   buildFilter(attribute, value, operator = "EQUAL", relativePath = void 0) {
     return buildFilter(attribute, value, operator, relativePath);
@@ -2046,32 +1990,25 @@ var CrudService = class {
     return buildSort(column, direction);
   }
   updateExpression(filters, actions, options) {
-    return this.getCrudServiceInstance().then(
-      (crudService) => crudService.updateExpressions(filters, actions, options)
-    );
+    return this.getCrudServiceInstance().then((crudService) => crudService.updateExpressions(filters, actions, options));
   }
   runRawQuery(query, params) {
-    return this.getCrudServiceInstance().then(
-      (crudService) => crudService.runRawQuery(query, params)
-    );
+    return this.getCrudServiceInstance().then((crudService) => crudService.runRawQuery(query, params));
   }
-};
+}, __name(_a, "CrudService"), _a);
 var crud_service_default = CrudService;
 
 // src/schemas/crudSchema.ts
-var CrudSchema = class {
+var _CrudSchema = class _CrudSchema {
 };
-CrudSchema.usePool = false;
-CrudSchema.schema = null;
-CrudSchema.isTemporalTable = false;
-
-// src/types/filterLogicOperator.type.ts
-Object.values(
-  FILTER_LOGIC_OPERATORS
-);
-
-// src/types/connectionClosingMode.type.ts
-Object.values(CONNECTION_CLOSING_MODES);
+__name(_CrudSchema, "CrudSchema");
+__publicField(_CrudSchema, "table");
+__publicField(_CrudSchema, "columns");
+__publicField(_CrudSchema, "usePool", false);
+__publicField(_CrudSchema, "schema", null);
+__publicField(_CrudSchema, "poolClient");
+__publicField(_CrudSchema, "isTemporalTable", false);
+var CrudSchema = _CrudSchema;
 var DEFAULT_DB_POOL_CONFIG = {
   max: 20,
   connectionTimeoutMillis: 10 * 1e3,
@@ -2086,14 +2023,13 @@ function getDbPool(poolConfig) {
   }), poolConfig));
   registerPool(pool);
   pool.on("error", (error) => {
-    console.error(
-      "[data-persistence] Unexpected PG pool error on idle client",
-      error
-    );
+    const serviceName = process.env.SERVICE_NAME ? `[${process.env.SERVICE_NAME}/data-persistence]` : "[data-persistence]";
+    console.error(`${serviceName} Unexpected PG pool error on idle client`, error);
   });
   return pool;
 }
+__name(getDbPool, "getDbPool");
 
-export { CrudSchema, crud_service_default as CrudService, DEFAULT_DB_POOL_CONFIG, buildFilter, buildQueryIndex, buildSort, closeAllClients, closeAllPools, getDbPool };
+export { CrudSchema, crud_service_default as CrudService, DEFAULT_DB_POOL_CONFIG, buildFilter, buildQueryIndex, buildSort, closeAllClients, closeAllPools, getDbPool, shutdown };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map