@qrvey/data-persistence 0.4.0 → 0.5.0-bundled

package/dist/esm/postgreSqlCrud.service-M7PR4CN6.mjs

@@ -1,809 +0,0 @@
-import { findIdColumnName, buildAggFunctionAlias, PersistenceErrorWrapper, getTableName } from './chunk-DHIGNHXS.mjs';
-import { __spreadValues, __spreadProps, DEFAULT_PG_SCHEMA, POSTGRES_FILTER_OPERATOR_MAP, DYNAMO_DB_UPDATE_ACTIONS } from './chunk-6MOAJFFY.mjs';
-import format from 'pg-format';
-import { Client } from 'pg';
-
-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(poolClient) {
-    this.poolClient = poolClient;
-    this.connectionService = new ConnectionService();
-  }
-  async runQuery(queryText, values) {
-    const client = await (this.poolClient ? this.poolClient : this.connectionService.getClient());
-    try {
-      const result = await client.query(queryText, values);
-      return result;
-    } catch (error) {
-      console.log("[Postgresql-Client] Query Execution Failed:", error);
-      throw error;
-    } finally {
-      if (!this.poolClient)
-        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);
-  }
-  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 = format.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 = format.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(format.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} ${format.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} ${format.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 `${format.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 ${format.ident(this.dbSchema)}.${format.ident(
-        this.tableName
-      )} (%I) VALUES %L RETURNING *;`,
-      keys,
-      values
-    );
-    return this.runQuery(query);
-  }
-  addFiltersToQuery(query, filters) {
-    if (!filters)
-      return query;
-    const isValidArrayFilters = Array.isArray(filters) && (filters == null ? void 0 : filters.length);
-    const isValidCompositeFilters = this.isCompositeFilter(filters);
-    if (isValidArrayFilters || isValidCompositeFilters)
-      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;
-  }
-  async findCommand(options = {}) {
-    let query = `SELECT ${this.getSelectClause(
-      options.aggregateFunction,
-      options.fields
-    )} FROM ${format.ident(this.dbSchema)}.${format.ident(this.tableName)}`;
-    query = this.addFiltersToQuery(query, options.filters);
-    if (!options.aggregateFunction) {
-      query = this.addOrderByToQuery(query, options.sorting);
-      query = this.addPaginationToQuery(query, options.pagination);
-    }
-    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 format.literal(value);
-    }
-  }
-  async updateCommand(filters, data) {
-    let query = `UPDATE ${format.ident(this.dbSchema)}.${format.ident(
-      this.tableName
-    )} SET`;
-    const updateClauses = Object.entries(data).map(([key, value]) => {
-      const dbValue = format.literal(this.formatValue(value));
-      return `${format.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 ${format.ident(this.dbSchema)}.${format.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 ${format.ident(this.dbSchema)}.${format.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 = format.literal(value);
-            expValue = `ARRAY[${formattedValue}]`;
-            break;
-          default:
-            formattedValue = format.literal(value);
-            expValue = formattedValue;
-            break;
-        }
-        this.crudSchema.columns;
-        updateClauses.push(`${format.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(
-            `${format.ident(queryFunction.path)} = ${jsonExpr}`
-          );
-        } else {
-          updateClauses.push(
-            `${format.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) {
-    super(tableSchema);
-    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 resultItem = __spreadValues(__spreadValues({}, data), data.qvAttributes);
-    delete resultItem["qvAttributes"];
-    return resultItem;
-  }
-  prepareData(data) {
-    const inputData = __spreadValues({}, data);
-    this.normalizeInputData(inputData);
-    return inputData;
-  }
-  create(data) {
-    if (Array.isArray(data)) {
-      const inputDataArray = data.map((item) => this.prepareData(item));
-      return this.createCommand(inputDataArray).then((result) => ({
-        unprocessedItems: result.filter((r) => !r.success).map((r) => r.inputData)
-      }));
-    } 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) {
-    const savedRecord = 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);
-  }
-};
-
-export { PostgreSqlCrudService };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=postgreSqlCrud.service-M7PR4CN6.mjs.map