querymongo 1.0.1 → 1.1.0

package/src/infrastructure/converters/UpdateConverter.ts

@@ -1,36 +0,0 @@
-/**
- * Conversor para queries UPDATE
- * Convierte UPDATE SQL a updateOne/updateMany de MongoDB
- */
-import type { IConverter } from "../../domain/interfaces/Converter.ts";
-import {
-  buildFilter,
-  determineOperation,
-  removeUndefinedFields,
-} from "../utils/queryUtils.ts";
-
-export const UpdateConverter: IConverter = {
-  can: (statement: string): boolean => {
-    return statement.toLowerCase().startsWith("update");
-  },
-
-  convert: (query: any): Record<string, any> => {
-    const { ast } = query;
-    const { table, set, where } = ast;
-
-    const collectionName = table?.[0]?.table || "collection";
-    const updateData = Object.fromEntries(
-      set.map((item: any) => [item.column, item.value?.value || item.value]),
-    );
-
-    return removeUndefinedFields({
-      collection: collectionName,
-      operation: determineOperation(where, {
-        one: "updateOne",
-        many: "updateMany",
-      }),
-      filter: where ? buildFilter(where) : {},
-      update: { $set: updateData },
-    });
-  },
-};

package/src/infrastructure/parser/sqlParser.ts

@@ -1,17 +0,0 @@
-/**
- * Parser SQL que encapsula node-sql-parser
- * Abstrae la dependencia externa y proporciona una interfaz limpia
- */
-import sqlParser from "node-sql-parser";
-
-const parser = new sqlParser.Parser();
-
-export type ParsedQuery = ReturnType<typeof parser.parse>;
-
-export const parseSqlQuery = (sql: string): ParsedQuery | ParsedQuery[] => {
-  return parser.parse(sql);
-};
-
-export const normalizeQuery = (query: string): string => {
-  return query.trim().replace(/;$/, "").replace(/\s+/g, " ");
-};

package/src/infrastructure/utils/queryUtils.ts

@@ -1,93 +0,0 @@
-/**
- * Utilidades para conversión de queries SQL a MongoDB
- * Centraliza lógica reutilizable siguiendo principio DRY
- */
-import _ from "lodash";
-
-export const removeUndefinedFields = (
-  obj: Record<string, any>,
-): Record<string, any> => {
-  return _.omitBy(obj, _.isUndefined);
-};
-
-export const normalizeFieldName = (field: string): string => {
-  return field.trim().replace(/`|"/g, "");
-};
-
-const normalizeFieldNames = (fields: string[]): string[] => {
-  return fields.map(normalizeFieldName);
-};
-
-export const buildProjection = (
-  fields: string[] | "*",
-): Record<string, 1 | 0> => {
-  if (fields === "*") return {};
-  return Object.fromEntries(normalizeFieldNames(fields).map((f) => [f, 1]));
-};
-
-export const buildFilter = (condition: any): Record<string, any> => {
-  if (!condition) return {};
-
-  const { operator, left, right } = condition;
-
-  if (!operator) return {};
-
-  if (operator.toUpperCase() === "AND") {
-    return {
-      $and: [buildFilter(left), buildFilter(right)],
-    };
-  }
-
-  if (operator.toUpperCase() === "OR") {
-    return {
-      $or: [buildFilter(left), buildFilter(right)],
-    };
-  }
-
-  const field = normalizeFieldName(left?.column || left?.value || left || "");
-  const value = right?.value !== undefined ? right.value : right;
-
-  const operatorMap: Record<string, string> = {
-    "=": "$eq",
-    "!=": "$ne",
-    "<>": "$ne",
-    "<": "$lt",
-    ">": "$gt",
-    "<=": "$lte",
-    ">=": "$gte",
-    like: "$regex",
-    in: "$in",
-    "not in": "$nin",
-  };
-
-  const mongoOp = operatorMap[operator.toLowerCase()];
-
-  return mongoOp ? { [field]: { [mongoOp]: value } } : {};
-};
-
-export function determineOperation(
-  where: any,
-  operations: { one: string; many: string },
-): string {
-  const uniqueFields = ["id", "_id", "email", "username"];
-  const { operator, left } = where;
-
-  if (!where) return operations.many;
-
-  if (["and", "or"].includes(operator?.toLowerCase())) {
-    return operations.many;
-  }
-
-  const field = left?.column || left?.value || left || "";
-  const isUniqueField = uniqueFields.includes(field?.toLowerCase?.());
-
-  if (isUniqueField && operator === "=") {
-    return operations.one;
-  }
-
-  return [">", "<", ">=", "<=", "!=", "<>", "like", "in"].includes(
-    operator?.toLowerCase(),
-  )
-    ? operations.many
-    : operations.one;
-}